Adjust device_registry.async_setup

.claude/agents/raise-pull-request.md

@@ -195,7 +195,6 @@ GITHUB_USER=$(gh api user --jq .login 2>/dev/null || git remote get-url "$PUSH_R
 # Create PR (gh pr create pushes the branch automatically)
 gh pr create --repo home-assistant/core --base dev \
   --head "$GITHUB_USER:$BRANCH" \
-  --draft \
   --title "TITLE_HERE" \
   --body "$(cat <<'EOF'
 BODY_HERE

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

@@ -1,7 +1,6 @@
 ---
 name: github-pr-reviewer
-description: Reviews GitHub pull requests and provides feedback comments.
-disallowedTools: Write, Edit
+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

.claude/skills/integrations/SKILL.md

@@ -3,27 +3,54 @@ name: Home Assistant Integration knowledge
 description: Everything you need to know to build, test and review Home Assistant Integrations. If you're looking at an integration, you must use this as your primary reference.
 ---
 
-## File Locations
+### File Locations
 - **Integration code**: `./homeassistant/components/<integration_domain>/`
 - **Integration tests**: `./tests/components/<integration_domain>/`
 
-## General guidelines
+## Integration Templates
 
-- When looking for examples, prefer integrations with the platinum or gold quality scale level first.
-- Polling intervals are NOT user-configurable. Never add scan_interval, update_interval, or polling frequency options to config flows or config entries.
-- 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.
+### 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
+```
 
-The following platforms have extra guidelines:
+An integration can have platforms as needed (e.g., `sensor.py`, `switch.py`, etc.). The following platforms have extra guidelines:
 - **Diagnostics**: [`platform-diagnostics.md`](platform-diagnostics.md) for diagnostic data collection
 - **Repairs**: [`platform-repairs.md`](platform-repairs.md) for user-actionable repair issues
 
+### Minimal Integration Checklist
+- [ ] `manifest.json` with required fields (domain, name, codeowners, etc.)
+- [ ] `__init__.py` with `async_setup_entry` and `async_unload_entry`
+- [ ] `config_flow.py` with UI configuration support
+- [ ] `const.py` with `DOMAIN` constant
+- [ ] `strings.json` with at least config flow text
+- [ ] Platform files (`sensor.py`, etc.) as needed
+- [ ] `quality_scale.yaml` with rule status tracking
 
 ## Integration Quality Scale
 
-- When validating the quality scale rules, check them at https://developers.home-assistant.io/docs/core/integration-quality-scale/rules
-- When implementing or reviewing an integration, always consider the quality scale rules, since they promote best practices.
+Home Assistant uses an Integration Quality Scale to ensure code quality and consistency. The quality level determines which rules apply:
 
-Template scale file: `./script/scaffold/templates/integration/integration/quality_scale.yaml`
+### 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
@@ -34,7 +61,726 @@ Template scale file: `./script/scaffold/templates/integration/integration/qualit
    - `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
 
-- Tests should avoid interacting or mocking internal integration details. For more info, see https://developers.home-assistant.io/docs/development_testing/#writing-tests-for-integrations
+- **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
+- **Patch Boundaries**: Only patch library or client methods when testing config flows. Do not patch methods defined in `config_flow.py`; exercise the flow logic end-to-end.
+- **Test Scenarios**:
+  - All flow initiation methods (user, discovery, import)
+  - Successful configuration paths
+  - Error recovery scenarios
+  - Prevention of duplicate entries
+  - Flow completion after errors
+  - Reauthentication/reconfigure flows
+
+### Testing
+- **Integration-specific tests** (recommended):
+  ```bash
+  pytest ./tests/components/<integration_domain> \
+    --cov=homeassistant.components.<integration_domain> \
+    --cov-report term-missing \
+    --durations-min=1 \
+    --durations=0 \
+    --numprocesses=auto
+  ```
+
+### Testing Best Practices
+- **Never access `hass.data` directly** - Use fixtures and proper integration setup instead
+- **Use snapshot testing** - For verifying entity states and attributes
+- **Test through integration setup** - Don't test entities in isolation
+- **Mock external APIs** - Use fixtures with realistic JSON data
+- **Verify registries** - Ensure entities are properly registered with devices
+
+### Config Flow Testing Template
+```python
+async def test_user_flow_success(hass, mock_api):
+    """Test successful user flow."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "user"
+
+    # Test form submission
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=TEST_USER_INPUT
+    )
+    assert result["type"] == FlowResultType.CREATE_ENTRY
+    assert result["title"] == "My Device"
+    assert result["data"] == TEST_USER_INPUT
+
+async def test_flow_connection_error(hass, mock_api_error):
+    """Test connection error handling."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=TEST_USER_INPUT
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["errors"] == {"base": "cannot_connect"}
+```
+
+### Entity Testing Patterns
+```python
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Overridden fixture to specify platforms to test."""
+    return [Platform.SENSOR]  # Or another specific platform as needed.
+
+@pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")
+async def test_entities(
+    hass: HomeAssistant,
+    snapshot: SnapshotAssertion,
+    entity_registry: er.EntityRegistry,
+    device_registry: dr.DeviceRegistry,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test the sensor entities."""
+    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
+
+    # Ensure entities are correctly assigned to device
+    device_entry = device_registry.async_get_device(
+        identifiers={(DOMAIN, "device_unique_id")}
+    )
+    assert device_entry
+    entity_entries = er.async_entries_for_config_entry(
+        entity_registry, mock_config_entry.entry_id
+    )
+    for entity_entry in entity_entries:
+        assert entity_entry.device_id == device_entry.id
+```
+
+### Mock Patterns
+```python
+# Modern integration fixture setup
+@pytest.fixture
+def mock_config_entry() -> MockConfigEntry:
+    """Return the default mocked config entry."""
+    return MockConfigEntry(
+        title="My Integration",
+        domain=DOMAIN,
+        data={CONF_HOST: "127.0.0.1", CONF_API_KEY: "test_key"},
+        unique_id="device_unique_id",
+    )
+
+@pytest.fixture
+def mock_device_api() -> Generator[MagicMock]:
+    """Return a mocked device API."""
+    with patch("homeassistant.components.my_integration.MyDeviceAPI", autospec=True) as api_mock:
+        api = api_mock.return_value
+        api.get_data.return_value = MyDeviceData.from_json(
+            load_fixture("device_data.json", DOMAIN)
+        )
+        yield api
+
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Fixture to specify platforms to test."""
+    return PLATFORMS
+
+@pytest.fixture
+async def init_integration(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_device_api: MagicMock,
+    platforms: list[Platform],
+) -> MockConfigEntry:
+    """Set up the integration for testing."""
+    mock_config_entry.add_to_hass(hass)
+
+    with patch("homeassistant.components.my_integration.PLATFORMS", platforms):
+        await hass.config_entries.async_setup(mock_config_entry.entry_id)
+        await hass.async_block_till_done()
+
+    return mock_config_entry
+```
+
+## Debugging & Troubleshooting
+
+### Common Issues & Solutions
+- **Integration won't load**: Check `manifest.json` syntax and required fields
+- **Entities not appearing**: Verify `unique_id` and `has_entity_name` implementation
+- **Config flow errors**: Check `strings.json` entries and error handling
+- **Discovery not working**: Verify manifest discovery configuration and callbacks
+- **Tests failing**: Check mock setup and async context
+
+### Debug Logging Setup
+```python
+# Enable debug logging in tests
+caplog.set_level(logging.DEBUG, logger="my_integration")
+
+# In integration code - use proper logging
+_LOGGER = logging.getLogger(__name__)
+_LOGGER.debug("Processing data: %s", data)  # Use lazy logging
+```
+
+### Validation Commands
+```bash
+# Check specific integration
+python -m script.hassfest --integration-path homeassistant/components/my_integration
+
+# Validate quality scale
+# Check quality_scale.yaml against current rules
+
+# Run integration tests with coverage
+pytest ./tests/components/my_integration \
+  --cov=homeassistant.components.my_integration \
+  --cov-report term-missing
+```

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

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

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

@@ -8,6 +8,29 @@ Platform exists as `homeassistant/components/<domain>/repairs.py`.
   - 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
@@ -18,4 +41,15 @@ Platform exists as `homeassistant/components/<domain>/repairs.py`.
   - `CRITICAL`: Reserved for extreme scenarios only
   - `ERROR`: Requires immediate user attention
   - `WARNING`: Indicates future potential breakage
+- **Additional Attributes**:
+  ```python
+  ir.async_create_issue(
+      hass, DOMAIN, "issue_id",
+      breaks_in_ha_version="2024.1.0",
+      is_fixable=True,
+      is_persistent=True,
+      severity=ir.IssueSeverity.ERROR,
+      translation_key="issue_description",
+  )
+  ```
 - Only create issues for problems users can potentially resolve

.github/copilot-instructions.md

@@ -11,9 +11,10 @@
 
 This repository contains the core of Home Assistant, a Python 3 based home automation application.
 
-## Git Commit Guidelines
+## Code Review Guidelines
 
-- **Do NOT amend, squash, or rebase commits that have already been pushed to the PR branch after the PR is opened** - Reviewers need to follow the commit history, as well as see what changed since their last review
+**Git commit practices during review:**
+- **Do NOT amend, squash, or rebase commits after review has started** - Reviewers need to see what changed since their last review
 
 ## Development Commands
 

.github/workflows/builder.yml

@@ -342,7 +342,7 @@ jobs:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
       - name: Install Cosign
-        uses: sigstore/cosign-installer@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
+        uses: sigstore/cosign-installer@ba7bc0a3fef59531c69a25acd34668d6d3fe6f22 # v4.1.0
         with:
           cosign-release: "v2.5.3"
 

.github/workflows/ci.yaml

@@ -1392,7 +1392,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'true'
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
         with:
           fail_ci_if_error: true
           flags: full-suite
@@ -1563,7 +1563,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'false'
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }} # zizmor: ignore[secrets-outside-env]
@@ -1591,7 +1591,7 @@ jobs:
         with:
           pattern: test-results-*
       - name: Upload test results to Codecov
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
         with:
           report_type: test_results
           fail_ci_if_error: true

.pre-commit-config.yaml

@@ -87,13 +87,6 @@ repos:
         language: script
         types: [text]
         files: ^(homeassistant/.+/manifest\.json|homeassistant/brands/.+\.json|pyproject\.toml|\.pre-commit-config\.yaml|script/gen_requirements_all\.py)$
-      - id: gen_copilot_instructions
-        name: gen_copilot_instructions
-        entry: script/run-in-env.sh python3 -m script.gen_copilot_instructions
-        pass_filenames: false
-        language: script
-        types: [text]
-        files: ^(AGENTS\.md|\.claude/skills/(?!github-pr-reviewer/).+/SKILL\.md|\.github/copilot-instructions\.md|script/gen_copilot_instructions\.py)$
       - id: hassfest
         name: hassfest
         entry: script/run-in-env.sh python3 -m script.hassfest

.strict-typing

@@ -174,7 +174,6 @@ homeassistant.components.dnsip.*
 homeassistant.components.doorbird.*
 homeassistant.components.dormakaba_dkey.*
 homeassistant.components.downloader.*
-homeassistant.components.dropbox.*
 homeassistant.components.droplet.*
 homeassistant.components.dsmr.*
 homeassistant.components.duckdns.*

AGENTS.md

@@ -2,9 +2,10 @@
 
 This repository contains the core of Home Assistant, a Python 3 based home automation application.
 
-## Git Commit Guidelines
+## Code Review Guidelines
 
-- **Do NOT amend, squash, or rebase commits that have already been pushed to the PR branch after the PR is opened** - Reviewers need to follow the commit history, as well as see what changed since their last review
+**Git commit practices during review:**
+- **Do NOT amend, squash, or rebase commits after review has started** - Reviewers need to see what changed since their last review
 
 ## Development Commands
 

CODEOWNERS

@@ -37,13 +37,6 @@ build.json @home-assistant/supervisor
 # Other code
 /homeassistant/scripts/check_config.py @kellerza
 
-# Agent Configurations
-AGENTS.md @home-assistant/core
-CLAUDE.md @home-assistant/core
-/.agent/ @home-assistant/core
-/.claude/ @home-assistant/core
-/.gemini/ @home-assistant/core
-
 # Integrations
 /homeassistant/components/abode/ @shred86
 /tests/components/abode/ @shred86
@@ -408,8 +401,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/dremel_3d_printer/ @tkdrob
 /homeassistant/components/drop_connect/ @ChandlerSystems @pfrazer
 /tests/components/drop_connect/ @ChandlerSystems @pfrazer
-/homeassistant/components/dropbox/ @bdr99
-/tests/components/dropbox/ @bdr99
 /homeassistant/components/droplet/ @sarahseidman
 /tests/components/droplet/ @sarahseidman
 /homeassistant/components/dsmr/ @Robbie1221
@@ -1308,8 +1299,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/pi_hole/ @shenxn
 /homeassistant/components/picnic/ @corneyl @codesalatdev
 /tests/components/picnic/ @corneyl @codesalatdev
-/homeassistant/components/picotts/ @rooggiieerr
-/tests/components/picotts/ @rooggiieerr
 /homeassistant/components/ping/ @jpbede
 /tests/components/ping/ @jpbede
 /homeassistant/components/plaato/ @JohNan

homeassistant/components/actron_air/__init__.py

@@ -36,10 +36,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) ->
             translation_key="auth_error",
         ) from err
     except ActronAirAPIError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="setup_connection_error",
-        ) from err
+        raise ConfigEntryNotReady from err
 
     system_coordinators: dict[str, ActronAirSystemCoordinator] = {}
     for system in systems:

homeassistant/components/actron_air/quality_scale.yaml

@@ -64,7 +64,7 @@ rules:
     status: exempt
     comment: Not required for this integration at this stage.
   entity-translations: todo
-  exception-translations: done
+  exception-translations: todo
   icon-translations: todo
   reconfiguration-flow: todo
   repair-issues:

homeassistant/components/actron_air/strings.json

@@ -55,9 +55,6 @@
     "auth_error": {
       "message": "Authentication failed, please reauthenticate"
     },
-    "setup_connection_error": {
-      "message": "Failed to connect to the Actron Air API"
-    },
     "update_error": {
       "message": "An error occurred while retrieving data from the Actron Air API: {error}"
     }

homeassistant/components/ai_task/task.py

@@ -74,8 +74,7 @@ async def _resolve_attachments(
             resolved_attachments.append(
                 conversation.Attachment(
                     media_content_id=media_content_id,
-                    mime_type=attachment.get("media_content_type")
-                    or image_data.content_type,
+                    mime_type=image_data.content_type,
                     path=temp_filename,
                 )
             )
@@ -90,7 +89,7 @@ async def _resolve_attachments(
             resolved_attachments.append(
                 conversation.Attachment(
                     media_content_id=media_content_id,
-                    mime_type=attachment.get("media_content_type") or media.mime_type,
+                    mime_type=media.mime_type,
                     path=media.path,
                 )
             )

homeassistant/components/airos/__init__.py

@@ -33,21 +33,14 @@ from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
 from .const import DEFAULT_SSL, DEFAULT_VERIFY_SSL, DOMAIN, SECTION_ADVANCED_SETTINGS
-from .coordinator import (
-    AirOSConfigEntry,
-    AirOSDataUpdateCoordinator,
-    AirOSFirmwareUpdateCoordinator,
-    AirOSRuntimeData,
-)
+from .coordinator import AirOSConfigEntry, AirOSDataUpdateCoordinator
 
 _PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
     Platform.BUTTON,
     Platform.SENSOR,
-    Platform.UPDATE,
 ]
 
-
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -93,20 +86,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirOSConfigEntry) -> boo
 
     airos_device = airos_class(**conn_data)
 
-    data_coordinator = AirOSDataUpdateCoordinator(
-        hass, entry, device_data, airos_device
-    )
-    await data_coordinator.async_config_entry_first_refresh()
+    coordinator = AirOSDataUpdateCoordinator(hass, entry, device_data, airos_device)
+    await coordinator.async_config_entry_first_refresh()
 
-    firmware_coordinator: AirOSFirmwareUpdateCoordinator | None = None
-    if device_data["fw_major"] >= 8:
-        firmware_coordinator = AirOSFirmwareUpdateCoordinator(hass, entry, airos_device)
-        await firmware_coordinator.async_config_entry_first_refresh()
-
-    entry.runtime_data = AirOSRuntimeData(
-        status=data_coordinator,
-        firmware=firmware_coordinator,
-    )
+    entry.runtime_data = coordinator
 
     await hass.config_entries.async_forward_entry_setups(entry, _PLATFORMS)
 

homeassistant/components/airos/binary_sensor.py

@@ -87,7 +87,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the AirOS binary sensors from a config entry."""
-    coordinator = config_entry.runtime_data.status
+    coordinator = config_entry.runtime_data
 
     entities = [
         AirOSBinarySensor(coordinator, description)

homeassistant/components/airos/button.py

@@ -31,9 +31,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the AirOS button from a config entry."""
-    async_add_entities(
-        [AirOSRebootButton(config_entry.runtime_data.status, REBOOT_BUTTON)]
-    )
+    async_add_entities([AirOSRebootButton(config_entry.runtime_data, REBOOT_BUTTON)])
 
 
 class AirOSRebootButton(AirOSEntity, ButtonEntity):

homeassistant/components/airos/const.py

@@ -5,7 +5,6 @@ from datetime import timedelta
 DOMAIN = "airos"
 
 SCAN_INTERVAL = timedelta(minutes=1)
-UPDATE_SCAN_INTERVAL = timedelta(days=1)
 
 MANUFACTURER = "Ubiquiti"
 

homeassistant/components/airos/coordinator.py

@@ -2,10 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
-from dataclasses import dataclass
 import logging
-from typing import Any, TypeVar
 
 from airos.airos6 import AirOS6, AirOS6Data
 from airos.airos8 import AirOS8, AirOS8Data
@@ -22,61 +19,20 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import DOMAIN, SCAN_INTERVAL, UPDATE_SCAN_INTERVAL
+from .const import DOMAIN, SCAN_INTERVAL
 
 _LOGGER = logging.getLogger(__name__)
 
-type AirOSDeviceDetect = AirOS8 | AirOS6
-type AirOSDataDetect = AirOS8Data | AirOS6Data
-type AirOSUpdateData = dict[str, Any]
+AirOSDeviceDetect = AirOS8 | AirOS6
+AirOSDataDetect = AirOS8Data | AirOS6Data
 
-type AirOSConfigEntry = ConfigEntry[AirOSRuntimeData]
-
-T = TypeVar("T", bound=AirOSDataDetect | AirOSUpdateData)
-
-
-@dataclass
-class AirOSRuntimeData:
-    """Data for AirOS config entry."""
-
-    status: AirOSDataUpdateCoordinator
-    firmware: AirOSFirmwareUpdateCoordinator | None
-
-
-async def async_fetch_airos_data(
-    airos_device: AirOSDeviceDetect,
-    update_method: Callable[[], Awaitable[T]],
-) -> T:
-    """Fetch data from AirOS device."""
-    try:
-        await airos_device.login()
-        return await update_method()
-    except AirOSConnectionAuthenticationError as err:
-        _LOGGER.exception("Error authenticating with airOS device")
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN, translation_key="invalid_auth"
-        ) from err
-    except (
-        AirOSConnectionSetupError,
-        AirOSDeviceConnectionError,
-        TimeoutError,
-    ) as err:
-        _LOGGER.error("Error connecting to airOS device: %s", err)
-        raise UpdateFailed(
-            translation_domain=DOMAIN,
-            translation_key="cannot_connect",
-        ) from err
-    except AirOSDataMissingError as err:
-        _LOGGER.error("Expected data not returned by airOS device: %s", err)
-        raise UpdateFailed(
-            translation_domain=DOMAIN,
-            translation_key="error_data_missing",
-        ) from err
+type AirOSConfigEntry = ConfigEntry[AirOSDataUpdateCoordinator]
 
 
 class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOSDataDetect]):
-    """Class to manage fetching AirOS status data from single endpoint."""
+    """Class to manage fetching AirOS data from single endpoint."""
 
+    airos_device: AirOSDeviceDetect
     config_entry: AirOSConfigEntry
 
     def __init__(
@@ -98,33 +54,28 @@ class AirOSDataUpdateCoordinator(DataUpdateCoordinator[AirOSDataDetect]):
         )
 
     async def _async_update_data(self) -> AirOSDataDetect:
-        """Fetch status data from AirOS."""
-        return await async_fetch_airos_data(self.airos_device, self.airos_device.status)
-
-
-class AirOSFirmwareUpdateCoordinator(DataUpdateCoordinator[AirOSUpdateData]):
-    """Class to manage fetching AirOS firmware."""
-
-    config_entry: AirOSConfigEntry
-
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        config_entry: AirOSConfigEntry,
-        airos_device: AirOSDeviceDetect,
-    ) -> None:
-        """Initialize the coordinator."""
-        self.airos_device = airos_device
-        super().__init__(
-            hass,
-            _LOGGER,
-            config_entry=config_entry,
-            name=DOMAIN,
-            update_interval=UPDATE_SCAN_INTERVAL,
-        )
-
-    async def _async_update_data(self) -> AirOSUpdateData:
-        """Fetch firmware data from AirOS."""
-        return await async_fetch_airos_data(
-            self.airos_device, self.airos_device.update_check
-        )
+        """Fetch data from AirOS."""
+        try:
+            await self.airos_device.login()
+            return await self.airos_device.status()
+        except AirOSConnectionAuthenticationError as err:
+            _LOGGER.exception("Error authenticating with airOS device")
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN, translation_key="invalid_auth"
+            ) from err
+        except (
+            AirOSConnectionSetupError,
+            AirOSDeviceConnectionError,
+            TimeoutError,
+        ) as err:
+            _LOGGER.error("Error connecting to airOS device: %s", err)
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="cannot_connect",
+            ) from err
+        except AirOSDataMissingError as err:
+            _LOGGER.error("Expected data not returned by airOS device: %s", err)
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="error_data_missing",
+            ) from err

homeassistant/components/airos/diagnostics.py

@@ -29,15 +29,5 @@ async def async_get_config_entry_diagnostics(
     """Return diagnostics for a config entry."""
     return {
         "entry_data": async_redact_data(entry.data, TO_REDACT_HA),
-        "data": {
-            "status_data": async_redact_data(
-                entry.runtime_data.status.data.to_dict(), TO_REDACT_AIROS
-            ),
-            "firmware_data": async_redact_data(
-                entry.runtime_data.firmware.data
-                if entry.runtime_data.firmware is not None
-                else {},
-                TO_REDACT_AIROS,
-            ),
-        },
+        "data": async_redact_data(entry.runtime_data.data.to_dict(), TO_REDACT_AIROS),
     }

homeassistant/components/airos/sensor.py

@@ -180,7 +180,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the AirOS sensors from a config entry."""
-    coordinator = config_entry.runtime_data.status
+    coordinator = config_entry.runtime_data
 
     entities = [AirOSSensor(coordinator, description) for description in COMMON_SENSORS]
 

homeassistant/components/airos/strings.json

@@ -206,12 +206,6 @@
     },
     "reboot_failed": {
       "message": "The device did not accept the reboot request. Try again, or check your device web interface for errors."
-    },
-    "update_connection_authentication_error": {
-      "message": "Authentication or connection failed during firmware update"
-    },
-    "update_error": {
-      "message": "Connection failed during firmware update"
     }
   }
 }

homeassistant/components/airos/update.py

@@ -1,101 +0,0 @@
-"""AirOS update component for Home Assistant."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any
-
-from airos.exceptions import AirOSConnectionAuthenticationError, AirOSException
-
-from homeassistant.components.update import (
-    UpdateDeviceClass,
-    UpdateEntity,
-    UpdateEntityFeature,
-)
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import DOMAIN
-from .coordinator import (
-    AirOSConfigEntry,
-    AirOSDataUpdateCoordinator,
-    AirOSFirmwareUpdateCoordinator,
-)
-from .entity import AirOSEntity
-
-PARALLEL_UPDATES = 0
-
-_LOGGER = logging.getLogger(__name__)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: AirOSConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the AirOS update entity from a config entry."""
-    runtime_data = config_entry.runtime_data
-
-    if runtime_data.firmware is None:  # Unsupported device
-        return
-    async_add_entities([AirOSUpdateEntity(runtime_data.status, runtime_data.firmware)])
-
-
-class AirOSUpdateEntity(AirOSEntity, UpdateEntity):
-    """Update entity for AirOS firmware updates."""
-
-    _attr_device_class = UpdateDeviceClass.FIRMWARE
-    _attr_supported_features = UpdateEntityFeature.INSTALL
-
-    def __init__(
-        self,
-        status: AirOSDataUpdateCoordinator,
-        firmware: AirOSFirmwareUpdateCoordinator,
-    ) -> None:
-        """Initialize the AirOS update entity."""
-        super().__init__(status)
-        self.status = status
-        self.firmware = firmware
-
-        self._attr_unique_id = f"{status.data.derived.mac}_firmware_update"
-
-    @property
-    def installed_version(self) -> str | None:
-        """Return the installed firmware version."""
-        return self.status.data.host.fwversion
-
-    @property
-    def latest_version(self) -> str | None:
-        """Return the latest firmware version."""
-        if not self.firmware.data.get("update", False):
-            return self.status.data.host.fwversion
-        return self.firmware.data.get("version")
-
-    @property
-    def release_url(self) -> str | None:
-        """Return the release url of the latest firmware."""
-        return self.firmware.data.get("changelog")
-
-    async def async_install(
-        self,
-        version: str | None,
-        backup: bool,
-        **kwargs: Any,
-    ) -> None:
-        """Handle the firmware update installation."""
-        _LOGGER.debug("Starting firmware update")
-        try:
-            await self.status.airos_device.login()
-            await self.status.airos_device.download()
-            await self.status.airos_device.install()
-        except AirOSConnectionAuthenticationError as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="update_connection_authentication_error",
-            ) from err
-        except AirOSException as err:
-            raise HomeAssistantError(
-                translation_domain=DOMAIN,
-                translation_key="update_error",
-            ) from err

homeassistant/components/anthropic/__init__.py

@@ -2,15 +2,19 @@
 
 from __future__ import annotations
 
-from homeassistant.config_entries import ConfigSubentry
+import anthropic
+
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
 from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     entity_registry as er,
     issue_registry as ir,
 )
+from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.helpers.typing import ConfigType
 
 from .const import (
@@ -20,11 +24,12 @@ from .const import (
     DOMAIN,
     LOGGER,
 )
-from .coordinator import AnthropicConfigEntry, AnthropicCoordinator
 
 PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
+type AnthropicConfigEntry = ConfigEntry[anthropic.AsyncClient]
+
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Anthropic."""
@@ -34,9 +39,29 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
 async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) -> bool:
     """Set up Anthropic from a config entry."""
-    coordinator = AnthropicCoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = coordinator
+    client = anthropic.AsyncAnthropic(
+        api_key=entry.data[CONF_API_KEY], http_client=get_async_client(hass)
+    )
+    try:
+        await client.models.list(timeout=10.0)
+    except anthropic.AuthenticationError as err:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="api_authentication_error",
+            translation_placeholders={"message": err.message},
+        ) from err
+    except anthropic.AnthropicError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="api_error",
+            translation_placeholders={
+                "message": err.message
+                if isinstance(err, anthropic.APIError)
+                else str(err)
+            },
+        ) from err
+
+    entry.runtime_data = client
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 

homeassistant/components/anthropic/coordinator.py

@@ -1,78 +0,0 @@
-"""Coordinator for the Anthropic integration."""
-
-from __future__ import annotations
-
-from datetime import timedelta
-
-import anthropic
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.httpx_client import get_async_client
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN, LOGGER
-
-UPDATE_INTERVAL_CONNECTED = timedelta(hours=12)
-UPDATE_INTERVAL_DISCONNECTED = timedelta(minutes=1)
-
-type AnthropicConfigEntry = ConfigEntry[AnthropicCoordinator]
-
-
-class AnthropicCoordinator(DataUpdateCoordinator[None]):
-    """DataUpdateCoordinator which uses different intervals after successful and unsuccessful updates."""
-
-    client: anthropic.AsyncAnthropic
-
-    def __init__(self, hass: HomeAssistant, config_entry: AnthropicConfigEntry) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            LOGGER,
-            config_entry=config_entry,
-            name=config_entry.title,
-            update_interval=UPDATE_INTERVAL_CONNECTED,
-            update_method=self.async_update_data,
-            always_update=False,
-        )
-        self.client = anthropic.AsyncAnthropic(
-            api_key=config_entry.data[CONF_API_KEY], http_client=get_async_client(hass)
-        )
-
-    @callback
-    def async_set_updated_data(self, data: None) -> None:
-        """Manually update data, notify listeners and update refresh interval."""
-        self.update_interval = UPDATE_INTERVAL_CONNECTED
-        super().async_set_updated_data(data)
-
-    async def async_update_data(self) -> None:
-        """Fetch data from the API."""
-        try:
-            self.update_interval = UPDATE_INTERVAL_DISCONNECTED
-            await self.client.models.list(timeout=10.0)
-            self.update_interval = UPDATE_INTERVAL_CONNECTED
-        except anthropic.APITimeoutError as err:
-            raise TimeoutError(err.message or str(err)) from err
-        except anthropic.AuthenticationError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="api_authentication_error",
-                translation_placeholders={"message": err.message},
-            ) from err
-        except anthropic.APIError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="api_error",
-                translation_placeholders={"message": err.message},
-            ) from err
-
-    def mark_connection_error(self) -> None:
-        """Mark the connection as having an error and reschedule background check."""
-        self.update_interval = UPDATE_INTERVAL_DISCONNECTED
-        if self.last_update_success:
-            self.last_update_success = False
-            self.async_update_listeners()
-            if self._listeners and not self.hass.is_stopping:
-                self._schedule_refresh()

homeassistant/components/anthropic/entity.py

@@ -82,11 +82,12 @@ from homeassistant.config_entries import ConfigSubentry
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import device_registry as dr, llm
+from homeassistant.helpers.entity import Entity
 from homeassistant.helpers.json import json_dumps
-from homeassistant.helpers.update_coordinator import CoordinatorEntity
 from homeassistant.util import slugify
 from homeassistant.util.json import JsonObjectType
 
+from . import AnthropicConfigEntry
 from .const import (
     CONF_CHAT_MODEL,
     CONF_CODE_EXECUTION,
@@ -110,7 +111,6 @@ from .const import (
     PROGRAMMATIC_TOOL_CALLING_UNSUPPORTED_MODELS,
     UNSUPPORTED_STRUCTURED_OUTPUT_MODELS,
 )
-from .coordinator import AnthropicConfigEntry, AnthropicCoordinator
 
 # Max number of back and forth with the LLM to generate a response
 MAX_TOOL_ITERATIONS = 10
@@ -658,7 +658,7 @@ def _create_token_stats(
     }
 
 
-class AnthropicBaseLLMEntity(CoordinatorEntity[AnthropicCoordinator]):
+class AnthropicBaseLLMEntity(Entity):
     """Anthropic base LLM entity."""
 
     _attr_has_entity_name = True
@@ -666,7 +666,6 @@ class AnthropicBaseLLMEntity(CoordinatorEntity[AnthropicCoordinator]):
 
     def __init__(self, entry: AnthropicConfigEntry, subentry: ConfigSubentry) -> None:
         """Initialize the entity."""
-        super().__init__(entry.runtime_data)
         self.entry = entry
         self.subentry = subentry
         self._attr_unique_id = subentry.subentry_id
@@ -878,8 +877,7 @@ class AnthropicBaseLLMEntity(CoordinatorEntity[AnthropicCoordinator]):
         if tools:
             model_args["tools"] = tools
 
-        coordinator = self.entry.runtime_data
-        client = coordinator.client
+        client = self.entry.runtime_data
 
         # To prevent infinite loops, we limit the number of iterations
         for _iteration in range(max_iterations):
@@ -901,24 +899,13 @@ class AnthropicBaseLLMEntity(CoordinatorEntity[AnthropicCoordinator]):
                 )
                 messages.extend(new_messages)
             except anthropic.AuthenticationError as err:
-                # Trigger coordinator to confirm the auth failure and trigger the reauth flow.
-                await coordinator.async_request_refresh()
+                self.entry.async_start_reauth(self.hass)
                 raise HomeAssistantError(
                     translation_domain=DOMAIN,
                     translation_key="api_authentication_error",
                     translation_placeholders={"message": err.message},
                 ) from err
-            except anthropic.APIConnectionError as err:
-                LOGGER.info("Connection error while talking to Anthropic: %s", err)
-                coordinator.mark_connection_error()
-                raise HomeAssistantError(
-                    translation_domain=DOMAIN,
-                    translation_key="api_error",
-                    translation_placeholders={"message": err.message},
-                ) from err
             except anthropic.AnthropicError as err:
-                # Non-connection error, mark connection as healthy
-                coordinator.async_set_updated_data(None)
                 raise HomeAssistantError(
                     translation_domain=DOMAIN,
                     translation_key="api_error",
@@ -930,7 +917,6 @@ class AnthropicBaseLLMEntity(CoordinatorEntity[AnthropicCoordinator]):
                 ) from err
 
             if not chat_log.unresponded_tool_results:
-                coordinator.async_set_updated_data(None)
                 break
 
 

homeassistant/components/anthropic/quality_scale.yaml

@@ -35,9 +35,9 @@ rules:
   config-entry-unloading: done
   docs-configuration-parameters: done
   docs-installation-parameters: done
-  entity-unavailable: done
+  entity-unavailable: todo
   integration-owner: done
-  log-when-unavailable: done
+  log-when-unavailable: todo
   parallel-updates:
     status: exempt
     comment: |

homeassistant/components/anthropic/repairs.py

@@ -58,7 +58,7 @@ class ModelDeprecatedRepairFlow(RepairsFlow):
         if entry.entry_id in self._model_list_cache:
             model_list = self._model_list_cache[entry.entry_id]
         else:
-            client = entry.runtime_data.client
+            client = entry.runtime_data
             model_list = [
                 model_option
                 for model_option in await get_model_list(client)

homeassistant/components/arcam_fmj/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["arcam"],
-  "requirements": ["arcam-fmj==1.8.3"],
+  "requirements": ["arcam-fmj==1.8.2"],
   "ssdp": [
     {
       "deviceType": "urn:schemas-upnp-org:device:MediaRenderer:1",

homeassistant/components/arcam_fmj/sensor.py

@@ -91,7 +91,6 @@ SENSORS: tuple[ArcamFmjSensorEntityDescription, ...] = (
         value_fn=lambda state: (
             vp.colorspace.name.lower()
             if (vp := state.get_incoming_video_parameters()) is not None
-            and vp.colorspace is not None
             else None
         ),
     ),

homeassistant/components/assist_satellite/strings.json

@@ -75,7 +75,7 @@
   },
   "services": {
     "announce": {
-      "description": "Lets an Assist satellite announce a message.",
+      "description": "Lets a satellite announce a message.",
       "fields": {
         "media_id": {
           "description": "The media ID to announce instead of using text-to-speech.",
@@ -94,10 +94,10 @@
           "name": "Preannounce media ID"
         }
       },
-      "name": "Announce on satellite"
+      "name": "Announce"
     },
     "ask_question": {
-      "description": "Lets an Assist satellite ask a question and get the user's response.",
+      "description": "Asks a question and gets the user's response.",
       "fields": {
         "answers": {
           "description": "Possible answers to the question.",
@@ -124,10 +124,10 @@
           "name": "Question media ID"
         }
       },
-      "name": "Ask question on satellite"
+      "name": "Ask question"
     },
     "start_conversation": {
-      "description": "Starts a conversation from an Assist satellite.",
+      "description": "Starts a conversation from a satellite.",
       "fields": {
         "extra_system_prompt": {
           "description": "Provide background information to the AI about the request.",
@@ -150,13 +150,13 @@
           "name": "Message"
         }
       },
-      "name": "Start conversation on satellite"
+      "name": "Start conversation"
     }
   },
   "title": "Assist satellite",
   "triggers": {
     "idle": {
-      "description": "Triggers after one or more Assist satellites become idle after having processed a command.",
+      "description": "Triggers after one or more voice assistant satellites become idle after having processed a command.",
       "fields": {
         "behavior": {
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
@@ -165,7 +165,7 @@
       "name": "Satellite became idle"
     },
     "listening": {
-      "description": "Triggers after one or more Assist satellites start listening for a command from someone.",
+      "description": "Triggers after one or more voice assistant satellites start listening for a command from someone.",
       "fields": {
         "behavior": {
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
@@ -174,7 +174,7 @@
       "name": "Satellite started listening"
     },
     "processing": {
-      "description": "Triggers after one or more Assist satellites start processing a command after having heard it.",
+      "description": "Triggers after one or more voice assistant satellites start processing a command after having heard it.",
       "fields": {
         "behavior": {
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
@@ -183,7 +183,7 @@
       "name": "Satellite started processing"
     },
     "responding": {
-      "description": "Triggers after one or more Assist satellites start responding to a command after having processed it, or start announcing something.",
+      "description": "Triggers after one or more voice assistant satellites start responding to a command after having processed it, or start announcing something.",
       "fields": {
         "behavior": {
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"

homeassistant/components/azure_storage/strings.json

@@ -54,7 +54,7 @@
       "message": "Storage account {account_name} not found"
     },
     "cannot_connect": {
-      "message": "Cannot connect to storage account {account_name}"
+      "message": "Can not connect to storage account {account_name}"
     },
     "container_not_found": {
       "message": "Storage container {container_name} not found"

homeassistant/components/casper_glow/__init__.py

@@ -16,7 +16,6 @@ PLATFORMS: list[Platform] = [
     Platform.BUTTON,
     Platform.LIGHT,
     Platform.SELECT,
-    Platform.SENSOR,
 ]
 
 

homeassistant/components/casper_glow/binary_sensor.py

@@ -4,11 +4,7 @@ from __future__ import annotations
 
 from pycasperglow import GlowState
 
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntity,
-)
-from homeassistant.const import EntityCategory
+from homeassistant.components.binary_sensor import BinarySensorEntity
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -25,12 +21,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up the binary sensor platform for Casper Glow."""
-    async_add_entities(
-        [
-            CasperGlowPausedBinarySensor(entry.runtime_data),
-            CasperGlowChargingBinarySensor(entry.runtime_data),
-        ]
-    )
+    async_add_entities([CasperGlowPausedBinarySensor(entry.runtime_data)])
 
 
 class CasperGlowPausedBinarySensor(CasperGlowEntity, BinarySensorEntity):
@@ -55,34 +46,6 @@ class CasperGlowPausedBinarySensor(CasperGlowEntity, BinarySensorEntity):
     @callback
     def _async_handle_state_update(self, state: GlowState) -> None:
         """Handle a state update from the device."""
-        if state.is_paused is not None and state.is_paused != self._attr_is_on:
+        if state.is_paused is not None:
             self._attr_is_on = state.is_paused
-            self.async_write_ha_state()
-
-
-class CasperGlowChargingBinarySensor(CasperGlowEntity, BinarySensorEntity):
-    """Binary sensor indicating whether the Casper Glow is charging."""
-
-    _attr_device_class = BinarySensorDeviceClass.BATTERY_CHARGING
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-
-    def __init__(self, coordinator: CasperGlowCoordinator) -> None:
-        """Initialize the charging binary sensor."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{format_mac(coordinator.device.address)}_charging"
-        if coordinator.device.state.is_charging is not None:
-            self._attr_is_on = coordinator.device.state.is_charging
-
-    async def async_added_to_hass(self) -> None:
-        """Register state update callback when entity is added."""
-        await super().async_added_to_hass()
-        self.async_on_remove(
-            self._device.register_callback(self._async_handle_state_update)
-        )
-
-    @callback
-    def _async_handle_state_update(self, state: GlowState) -> None:
-        """Handle a state update from the device."""
-        if state.is_charging is not None and state.is_charging != self._attr_is_on:
-            self._attr_is_on = state.is_charging
-            self.async_write_ha_state()
+        self.async_write_ha_state()

homeassistant/components/casper_glow/quality_scale.yaml

@@ -53,15 +53,15 @@ rules:
   docs-use-cases: todo
   dynamic-devices: todo
   entity-category: done
-  entity-device-class: done
+  entity-device-class:
+    status: exempt
+    comment: No applicable device classes for binary_sensor, button, light, or select entities.
   entity-disabled-by-default: todo
   entity-translations: done
   exception-translations: done
   icon-translations: done
   reconfiguration-flow: todo
-  repair-issues:
-    status: exempt
-    comment: Integration does not register repair issues.
+  repair-issues: todo
   stale-devices: todo
 
   # Platinum

homeassistant/components/casper_glow/sensor.py

@@ -1,61 +0,0 @@
-"""Casper Glow integration sensor platform."""
-
-from __future__ import annotations
-
-from pycasperglow import GlowState
-
-from homeassistant.components.sensor import (
-    SensorDeviceClass,
-    SensorEntity,
-    SensorStateClass,
-)
-from homeassistant.const import PERCENTAGE, EntityCategory
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers.device_registry import format_mac
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .coordinator import CasperGlowConfigEntry, CasperGlowCoordinator
-from .entity import CasperGlowEntity
-
-PARALLEL_UPDATES = 0
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    entry: CasperGlowConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up the sensor platform for Casper Glow."""
-    async_add_entities([CasperGlowBatterySensor(entry.runtime_data)])
-
-
-class CasperGlowBatterySensor(CasperGlowEntity, SensorEntity):
-    """Sensor entity for Casper Glow battery level."""
-
-    _attr_device_class = SensorDeviceClass.BATTERY
-    _attr_native_unit_of_measurement = PERCENTAGE
-    _attr_state_class = SensorStateClass.MEASUREMENT
-    _attr_entity_category = EntityCategory.DIAGNOSTIC
-
-    def __init__(self, coordinator: CasperGlowCoordinator) -> None:
-        """Initialize the battery sensor."""
-        super().__init__(coordinator)
-        self._attr_unique_id = f"{format_mac(coordinator.device.address)}_battery"
-        if coordinator.device.state.battery_level is not None:
-            self._attr_native_value = coordinator.device.state.battery_level.percentage
-
-    async def async_added_to_hass(self) -> None:
-        """Register state update callback when entity is added."""
-        await super().async_added_to_hass()
-        self.async_on_remove(
-            self._device.register_callback(self._async_handle_state_update)
-        )
-
-    @callback
-    def _async_handle_state_update(self, state: GlowState) -> None:
-        """Handle a state update from the device."""
-        if state.battery_level is not None:
-            new_value = state.battery_level.percentage
-            if new_value != self._attr_native_value:
-                self._attr_native_value = new_value
-                self.async_write_ha_state()

homeassistant/components/climate/strings.json

@@ -239,7 +239,7 @@
       "message": "Provided humidity {humidity} is not valid. Accepted range is {min_humidity} to {max_humidity}."
     },
     "low_temp_higher_than_high_temp": {
-      "message": "'Lower target temperature' cannot be higher than 'Upper target temperature'."
+      "message": "'Lower target temperature' can not be higher than 'Upper target temperature'."
     },
     "missing_target_temperature_entity_feature": {
       "message": "Set temperature action was used with the 'Target temperature' parameter but the entity does not support it."

homeassistant/components/device_tracker/__init__.py

@@ -21,7 +21,6 @@ from .const import (  # noqa: F401
     ATTR_DEV_ID,
     ATTR_GPS,
     ATTR_HOST_NAME,
-    ATTR_IN_ZONES,
     ATTR_IP,
     ATTR_LOCATION_NAME,
     ATTR_MAC,

homeassistant/components/device_tracker/config_entry.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import asyncio
-from typing import Any, final
+from typing import final
 
 from propcache.api import cached_property
 
@@ -18,7 +18,7 @@ from homeassistant.const import (
     STATE_NOT_HOME,
     EntityCategory,
 )
-from homeassistant.core import Event, HomeAssistant, State, callback
+from homeassistant.core import Event, HomeAssistant, callback
 from homeassistant.helpers import device_registry as dr, entity_registry as er
 from homeassistant.helpers.device_registry import (
     DeviceInfo,
@@ -33,7 +33,6 @@ from homeassistant.util.hass_dict import HassKey
 
 from .const import (
     ATTR_HOST_NAME,
-    ATTR_IN_ZONES,
     ATTR_IP,
     ATTR_MAC,
     ATTR_SOURCE_TYPE,
@@ -224,9 +223,6 @@ class TrackerEntity(
     _attr_longitude: float | None = None
     _attr_source_type: SourceType = SourceType.GPS
 
-    __active_zone: State | None = None
-    __in_zones: list[str] | None = None
-
     @cached_property
     def should_poll(self) -> bool:
         """No polling for entities that have location pushed."""
@@ -260,18 +256,6 @@ class TrackerEntity(
         """Return longitude value of the device."""
         return self._attr_longitude
 
-    @callback
-    def _async_write_ha_state(self) -> None:
-        """Calculate active zones."""
-        if self.available and self.latitude is not None and self.longitude is not None:
-            self.__active_zone, self.__in_zones = zone.async_in_zones(
-                self.hass, self.latitude, self.longitude, self.location_accuracy
-            )
-        else:
-            self.__active_zone = None
-            self.__in_zones = None
-        super()._async_write_ha_state()
-
     @property
     def state(self) -> str | None:
         """Return the state of the device."""
@@ -279,7 +263,9 @@ class TrackerEntity(
             return self.location_name
 
         if self.latitude is not None and self.longitude is not None:
-            zone_state = self.__active_zone
+            zone_state = zone.async_active_zone(
+                self.hass, self.latitude, self.longitude, self.location_accuracy
+            )
             if zone_state is None:
                 state = STATE_NOT_HOME
             elif zone_state.entity_id == zone.ENTITY_ID_HOME:
@@ -292,13 +278,12 @@ class TrackerEntity(
 
     @final
     @property
-    def state_attributes(self) -> dict[str, Any]:
+    def state_attributes(self) -> dict[str, StateType]:
         """Return the device state attributes."""
-        attr: dict[str, Any] = {ATTR_IN_ZONES: []}
+        attr: dict[str, StateType] = {}
         attr.update(super().state_attributes)
 
         if self.latitude is not None and self.longitude is not None:
-            attr[ATTR_IN_ZONES] = self.__in_zones or []
             attr[ATTR_LATITUDE] = self.latitude
             attr[ATTR_LONGITUDE] = self.longitude
             attr[ATTR_GPS_ACCURACY] = self.location_accuracy

homeassistant/components/device_tracker/const.py

@@ -43,7 +43,6 @@ ATTR_BATTERY: Final = "battery"
 ATTR_DEV_ID: Final = "dev_id"
 ATTR_GPS: Final = "gps"
 ATTR_HOST_NAME: Final = "host_name"
-ATTR_IN_ZONES: Final = "in_zones"
 ATTR_LOCATION_NAME: Final = "location_name"
 ATTR_MAC: Final = "mac"
 ATTR_SOURCE_TYPE: Final = "source_type"

homeassistant/components/dropbox/__init__.py

@@ -1,64 +0,0 @@
-"""The Dropbox integration."""
-
-from __future__ import annotations
-
-from python_dropbox_api import (
-    DropboxAPIClient,
-    DropboxAuthException,
-    DropboxUnknownException,
-)
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import aiohttp_client
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    ImplementationUnavailableError,
-    OAuth2Session,
-    async_get_config_entry_implementation,
-)
-
-from .auth import DropboxConfigEntryAuth
-from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
-
-type DropboxConfigEntry = ConfigEntry[DropboxAPIClient]
-
-
-async def async_setup_entry(hass: HomeAssistant, entry: DropboxConfigEntry) -> bool:
-    """Set up Dropbox from a config entry."""
-    try:
-        oauth2_implementation = await async_get_config_entry_implementation(hass, entry)
-    except ImplementationUnavailableError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="oauth2_implementation_unavailable",
-        ) from err
-    oauth2_session = OAuth2Session(hass, entry, oauth2_implementation)
-
-    auth = DropboxConfigEntryAuth(
-        aiohttp_client.async_get_clientsession(hass), oauth2_session
-    )
-
-    client = DropboxAPIClient(auth)
-
-    try:
-        await client.get_account_info()
-    except DropboxAuthException as err:
-        raise ConfigEntryAuthFailed from err
-    except (DropboxUnknownException, TimeoutError) as err:
-        raise ConfigEntryNotReady from err
-
-    entry.runtime_data = client
-
-    def async_notify_backup_listeners() -> None:
-        for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
-            listener()
-
-    entry.async_on_unload(entry.async_on_state_change(async_notify_backup_listeners))
-
-    return True
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: DropboxConfigEntry) -> bool:
-    """Unload a config entry."""
-    return True

homeassistant/components/dropbox/application_credentials.py

@@ -1,38 +0,0 @@
-"""Application credentials platform for the Dropbox integration."""
-
-from homeassistant.components.application_credentials import ClientCredential
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.config_entry_oauth2_flow import (
-    AbstractOAuth2Implementation,
-    LocalOAuth2ImplementationWithPkce,
-)
-
-from .const import OAUTH2_AUTHORIZE, OAUTH2_SCOPES, OAUTH2_TOKEN
-
-
-async def async_get_auth_implementation(
-    hass: HomeAssistant, auth_domain: str, credential: ClientCredential
-) -> AbstractOAuth2Implementation:
-    """Return custom auth implementation."""
-    return DropboxOAuth2Implementation(
-        hass,
-        auth_domain,
-        credential.client_id,
-        OAUTH2_AUTHORIZE,
-        OAUTH2_TOKEN,
-        credential.client_secret,
-    )
-
-
-class DropboxOAuth2Implementation(LocalOAuth2ImplementationWithPkce):
-    """Custom Dropbox OAuth2 implementation to add the necessary authorize url parameters."""
-
-    @property
-    def extra_authorize_data(self) -> dict:
-        """Extra data that needs to be appended to the authorize url."""
-        data: dict = {
-            "token_access_type": "offline",
-            "scope": " ".join(OAUTH2_SCOPES),
-        }
-        data.update(super().extra_authorize_data)
-        return data

homeassistant/components/dropbox/auth.py

@@ -1,44 +0,0 @@
-"""Authentication for Dropbox."""
-
-from typing import cast
-
-from aiohttp import ClientSession
-from python_dropbox_api import Auth
-
-from homeassistant.helpers.config_entry_oauth2_flow import OAuth2Session
-
-
-class DropboxConfigEntryAuth(Auth):
-    """Provide Dropbox authentication tied to an OAuth2 based config entry."""
-
-    def __init__(
-        self,
-        websession: ClientSession,
-        oauth_session: OAuth2Session,
-    ) -> None:
-        """Initialize DropboxConfigEntryAuth."""
-        super().__init__(websession)
-        self._oauth_session = oauth_session
-
-    async def async_get_access_token(self) -> str:
-        """Return a valid access token."""
-        await self._oauth_session.async_ensure_token_valid()
-
-        return cast(str, self._oauth_session.token["access_token"])
-
-
-class DropboxConfigFlowAuth(Auth):
-    """Provide authentication tied to a fixed token for the config flow."""
-
-    def __init__(
-        self,
-        websession: ClientSession,
-        token: str,
-    ) -> None:
-        """Initialize DropboxConfigFlowAuth."""
-        super().__init__(websession)
-        self._token = token
-
-    async def async_get_access_token(self) -> str:
-        """Return the fixed access token."""
-        return self._token

homeassistant/components/dropbox/backup.py

@@ -1,230 +0,0 @@
-"""Backup platform for the Dropbox integration."""
-
-from collections.abc import AsyncIterator, Callable, Coroutine
-from functools import wraps
-import json
-import logging
-from typing import Any, Concatenate
-
-from python_dropbox_api import (
-    DropboxAPIClient,
-    DropboxAuthException,
-    DropboxFileOrFolderNotFoundException,
-    DropboxUnknownException,
-)
-
-from homeassistant.components.backup import (
-    AgentBackup,
-    BackupAgent,
-    BackupAgentError,
-    BackupNotFound,
-    suggested_filename,
-)
-from homeassistant.core import HomeAssistant, callback
-
-from . import DropboxConfigEntry
-from .const import DATA_BACKUP_AGENT_LISTENERS, DOMAIN
-
-_LOGGER = logging.getLogger(__name__)
-
-
-def _suggested_filenames(backup: AgentBackup) -> tuple[str, str]:
-    """Return the suggested filenames for the backup and metadata."""
-    base_name = suggested_filename(backup).rsplit(".", 1)[0]
-    return f"{base_name}.tar", f"{base_name}.metadata.json"
-
-
-async def _async_string_iterator(content: str) -> AsyncIterator[bytes]:
-    """Yield a string as a single bytes chunk."""
-    yield content.encode()
-
-
-def handle_backup_errors[_R, **P](
-    func: Callable[Concatenate[DropboxBackupAgent, P], Coroutine[Any, Any, _R]],
-) -> Callable[Concatenate[DropboxBackupAgent, P], Coroutine[Any, Any, _R]]:
-    """Handle backup errors."""
-
-    @wraps(func)
-    async def wrapper(
-        self: DropboxBackupAgent, *args: P.args, **kwargs: P.kwargs
-    ) -> _R:
-        try:
-            return await func(self, *args, **kwargs)
-        except DropboxFileOrFolderNotFoundException as err:
-            raise BackupNotFound(
-                f"Failed to {func.__name__.removeprefix('async_').replace('_', ' ')}"
-            ) from err
-        except DropboxAuthException as err:
-            self._entry.async_start_reauth(self._hass)
-            raise BackupAgentError("Authentication error") from err
-        except DropboxUnknownException as err:
-            _LOGGER.error(
-                "Error during %s: %s",
-                func.__name__,
-                err,
-            )
-            _LOGGER.debug("Full error: %s", err, exc_info=True)
-            raise BackupAgentError(
-                f"Failed to {func.__name__.removeprefix('async_').replace('_', ' ')}"
-            ) from err
-
-    return wrapper
-
-
-async def async_get_backup_agents(
-    hass: HomeAssistant,
-    **kwargs: Any,
-) -> list[BackupAgent]:
-    """Return a list of backup agents."""
-    entries = hass.config_entries.async_loaded_entries(DOMAIN)
-    return [DropboxBackupAgent(hass, entry) for entry in entries]
-
-
-@callback
-def async_register_backup_agents_listener(
-    hass: HomeAssistant,
-    *,
-    listener: Callable[[], None],
-    **kwargs: Any,
-) -> Callable[[], None]:
-    """Register a listener to be called when agents are added or removed.
-
-    :return: A function to unregister the listener.
-    """
-    hass.data.setdefault(DATA_BACKUP_AGENT_LISTENERS, []).append(listener)
-
-    @callback
-    def remove_listener() -> None:
-        """Remove the listener."""
-        hass.data[DATA_BACKUP_AGENT_LISTENERS].remove(listener)
-        if not hass.data[DATA_BACKUP_AGENT_LISTENERS]:
-            del hass.data[DATA_BACKUP_AGENT_LISTENERS]
-
-    return remove_listener
-
-
-class DropboxBackupAgent(BackupAgent):
-    """Backup agent for the Dropbox integration."""
-
-    domain = DOMAIN
-
-    def __init__(self, hass: HomeAssistant, entry: DropboxConfigEntry) -> None:
-        """Initialize the backup agent."""
-        super().__init__()
-        self._hass = hass
-        self._entry = entry
-        self.name = entry.title
-        assert entry.unique_id
-        self.unique_id = entry.unique_id
-        self._api: DropboxAPIClient = entry.runtime_data
-
-    async def _async_get_backups(self) -> list[tuple[AgentBackup, str]]:
-        """Get backups and their corresponding file names."""
-        files = await self._api.list_folder("")
-
-        tar_files = {f.name for f in files if f.name.endswith(".tar")}
-        metadata_files = [f for f in files if f.name.endswith(".metadata.json")]
-
-        backups: list[tuple[AgentBackup, str]] = []
-        for metadata_file in metadata_files:
-            tar_name = metadata_file.name.removesuffix(".metadata.json") + ".tar"
-            if tar_name not in tar_files:
-                _LOGGER.warning(
-                    "Found metadata file '%s' without matching backup file",
-                    metadata_file.name,
-                )
-                continue
-
-            metadata_stream = self._api.download_file(f"/{metadata_file.name}")
-            raw = b"".join([chunk async for chunk in metadata_stream])
-            try:
-                data = json.loads(raw)
-                backup = AgentBackup.from_dict(data)
-            except (json.JSONDecodeError, ValueError, TypeError, KeyError) as err:
-                _LOGGER.warning(
-                    "Skipping invalid metadata file '%s': %s",
-                    metadata_file.name,
-                    err,
-                )
-                continue
-            backups.append((backup, tar_name))
-
-        return backups
-
-    @handle_backup_errors
-    async def async_upload_backup(
-        self,
-        *,
-        open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]],
-        backup: AgentBackup,
-        **kwargs: Any,
-    ) -> None:
-        """Upload a backup."""
-        backup_filename, metadata_filename = _suggested_filenames(backup)
-        backup_path = f"/{backup_filename}"
-        metadata_path = f"/{metadata_filename}"
-
-        file_stream = await open_stream()
-        await self._api.upload_file(backup_path, file_stream)
-
-        metadata_stream = _async_string_iterator(json.dumps(backup.as_dict()))
-
-        try:
-            await self._api.upload_file(metadata_path, metadata_stream)
-        except (
-            DropboxAuthException,
-            DropboxUnknownException,
-        ):
-            await self._api.delete_file(backup_path)
-            raise
-
-    @handle_backup_errors
-    async def async_list_backups(self, **kwargs: Any) -> list[AgentBackup]:
-        """List backups."""
-        return [backup for backup, _ in await self._async_get_backups()]
-
-    @handle_backup_errors
-    async def async_download_backup(
-        self,
-        backup_id: str,
-        **kwargs: Any,
-    ) -> AsyncIterator[bytes]:
-        """Download a backup file."""
-        backups = await self._async_get_backups()
-        for backup, filename in backups:
-            if backup.backup_id == backup_id:
-                return self._api.download_file(f"/{filename}")
-
-        raise BackupNotFound(f"Backup {backup_id} not found")
-
-    @handle_backup_errors
-    async def async_get_backup(
-        self,
-        backup_id: str,
-        **kwargs: Any,
-    ) -> AgentBackup:
-        """Return a backup."""
-        backups = await self._async_get_backups()
-
-        for backup, _ in backups:
-            if backup.backup_id == backup_id:
-                return backup
-
-        raise BackupNotFound(f"Backup {backup_id} not found")
-
-    @handle_backup_errors
-    async def async_delete_backup(
-        self,
-        backup_id: str,
-        **kwargs: Any,
-    ) -> None:
-        """Delete a backup file."""
-        backups = await self._async_get_backups()
-        for backup, tar_filename in backups:
-            if backup.backup_id == backup_id:
-                metadata_filename = tar_filename.removesuffix(".tar") + ".metadata.json"
-                await self._api.delete_file(f"/{tar_filename}")
-                await self._api.delete_file(f"/{metadata_filename}")
-                return
-
-        raise BackupNotFound(f"Backup {backup_id} not found")

homeassistant/components/dropbox/config_flow.py

@@ -1,60 +0,0 @@
-"""Config flow for Dropbox."""
-
-from collections.abc import Mapping
-import logging
-from typing import Any
-
-from python_dropbox_api import DropboxAPIClient
-
-from homeassistant.config_entries import SOURCE_REAUTH, ConfigFlowResult
-from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.config_entry_oauth2_flow import AbstractOAuth2FlowHandler
-
-from .auth import DropboxConfigFlowAuth
-from .const import DOMAIN
-
-
-class DropboxConfigFlow(AbstractOAuth2FlowHandler, domain=DOMAIN):
-    """Config flow to handle Dropbox OAuth2 authentication."""
-
-    DOMAIN = DOMAIN
-
-    @property
-    def logger(self) -> logging.Logger:
-        """Return logger."""
-        return logging.getLogger(__name__)
-
-    async def async_oauth_create_entry(self, data: dict[str, Any]) -> ConfigFlowResult:
-        """Create an entry for the flow, or update existing entry."""
-        access_token = data[CONF_TOKEN][CONF_ACCESS_TOKEN]
-
-        auth = DropboxConfigFlowAuth(async_get_clientsession(self.hass), access_token)
-
-        client = DropboxAPIClient(auth)
-        account_info = await client.get_account_info()
-
-        await self.async_set_unique_id(account_info.account_id)
-        if self.source == SOURCE_REAUTH:
-            self._abort_if_unique_id_mismatch(reason="wrong_account")
-            return self.async_update_reload_and_abort(
-                self._get_reauth_entry(), data=data
-            )
-
-        self._abort_if_unique_id_configured()
-
-        return self.async_create_entry(title=account_info.email, data=data)
-
-    async def async_step_reauth(
-        self, entry_data: Mapping[str, Any]
-    ) -> ConfigFlowResult:
-        """Perform reauth upon an API authentication error."""
-        return await self.async_step_reauth_confirm()
-
-    async def async_step_reauth_confirm(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Dialog that informs the user that reauth is required."""
-        if user_input is None:
-            return self.async_show_form(step_id="reauth_confirm")
-        return await self.async_step_user()

homeassistant/components/dropbox/const.py

@@ -1,19 +0,0 @@
-"""Constants for the Dropbox integration."""
-
-from collections.abc import Callable
-
-from homeassistant.util.hass_dict import HassKey
-
-DOMAIN = "dropbox"
-
-OAUTH2_AUTHORIZE = "https://www.dropbox.com/oauth2/authorize"
-OAUTH2_TOKEN = "https://api.dropboxapi.com/oauth2/token"
-OAUTH2_SCOPES = [
-    "account_info.read",
-    "files.content.read",
-    "files.content.write",
-]
-
-DATA_BACKUP_AGENT_LISTENERS: HassKey[list[Callable[[], None]]] = HassKey(
-    f"{DOMAIN}.backup_agent_listeners"
-)

homeassistant/components/dropbox/manifest.json

@@ -1,13 +0,0 @@
-{
-  "domain": "dropbox",
-  "name": "Dropbox",
-  "after_dependencies": ["backup"],
-  "codeowners": ["@bdr99"],
-  "config_flow": true,
-  "dependencies": ["application_credentials"],
-  "documentation": "https://www.home-assistant.io/integrations/dropbox",
-  "integration_type": "service",
-  "iot_class": "cloud_polling",
-  "quality_scale": "bronze",
-  "requirements": ["python-dropbox-api==0.1.3"]
-}

homeassistant/components/dropbox/quality_scale.yaml

@@ -1,112 +0,0 @@
-rules:
-  # Bronze
-  action-setup:
-    status: exempt
-    comment: Integration does not register any actions.
-  appropriate-polling:
-    status: exempt
-    comment: Integration does not poll.
-  brands: done
-  common-modules:
-    status: exempt
-    comment: Integration does not have any entities or coordinators.
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency: done
-  docs-actions:
-    status: exempt
-    comment: Integration does not register any actions.
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: Integration does not have any entities.
-  entity-unique-id:
-    status: exempt
-    comment: Integration does not have any entities.
-  has-entity-name:
-    status: exempt
-    comment: Integration does not have any entities.
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions:
-    status: exempt
-    comment: Integration does not register any actions.
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: Integration does not have any configuration parameters.
-  docs-installation-parameters: done
-  entity-unavailable:
-    status: exempt
-    comment: Integration does not have any entities.
-  integration-owner: done
-  log-when-unavailable: todo
-  parallel-updates:
-    status: exempt
-    comment: Integration does not make any entity updates.
-  reauthentication-flow: done
-  test-coverage: done
-
-  # Gold
-  devices:
-    status: exempt
-    comment: Integration does not have any entities.
-  diagnostics:
-    status: exempt
-    comment: Integration does not have any data to diagnose.
-  discovery-update-info:
-    status: exempt
-    comment: Integration is a service.
-  discovery:
-    status: exempt
-    comment: Integration is a service.
-  docs-data-update:
-    status: exempt
-    comment: Integration does not update any data.
-  docs-examples:
-    status: exempt
-    comment: Integration only provides backup functionality.
-  docs-known-limitations: todo
-  docs-supported-devices:
-    status: exempt
-    comment: Integration does not support any devices.
-  docs-supported-functions: done
-  docs-troubleshooting: todo
-  docs-use-cases: done
-  dynamic-devices:
-    status: exempt
-    comment: Integration does not use any devices.
-  entity-category:
-    status: exempt
-    comment: Integration does not have any entities.
-  entity-device-class:
-    status: exempt
-    comment: Integration does not have any entities.
-  entity-disabled-by-default:
-    status: exempt
-    comment: Integration does not have any entities.
-  entity-translations:
-    status: exempt
-    comment: Integration does not have any entities.
-  exception-translations: todo
-  icon-translations:
-    status: exempt
-    comment: Integration does not have any entities.
-  reconfiguration-flow: todo
-  repair-issues:
-    status: exempt
-    comment: Integration does not have any repairs.
-  stale-devices:
-    status: exempt
-    comment: Integration does not have any devices.
-
-  # Platinum
-  async-dependency: done
-  inject-websession: done
-  strict-typing: done

homeassistant/components/dropbox/strings.json

@@ -1,35 +0,0 @@
-{
-  "config": {
-    "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_account%]",
-      "already_in_progress": "[%key:common::config_flow::abort::already_in_progress%]",
-      "authorize_url_timeout": "[%key:common::config_flow::abort::oauth2_authorize_url_timeout%]",
-      "missing_configuration": "[%key:common::config_flow::abort::oauth2_missing_configuration%]",
-      "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",
-      "oauth_error": "[%key:common::config_flow::abort::oauth2_error%]",
-      "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
-      "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
-      "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "user_rejected_authorize": "[%key:common::config_flow::abort::oauth2_user_rejected_authorize%]",
-      "wrong_account": "Wrong account: Please authenticate with the correct account."
-    },
-    "create_entry": {
-      "default": "[%key:common::config_flow::create_entry::authenticated%]"
-    },
-    "step": {
-      "pick_implementation": {
-        "title": "[%key:common::config_flow::title::oauth2_pick_implementation%]"
-      },
-      "reauth_confirm": {
-        "description": "The Dropbox integration needs to re-authenticate your account.",
-        "title": "[%key:common::config_flow::title::reauth%]"
-      }
-    }
-  },
-  "exceptions": {
-    "oauth2_implementation_unavailable": {
-      "message": "[%key:common::exceptions::oauth2_implementation_unavailable::message%]"
-    }
-  }
-}

homeassistant/components/dwd_weather_warnings/strings.json

@@ -5,7 +5,7 @@
       "invalid_identifier": "[%key:component::dwd_weather_warnings::config::error::invalid_identifier%]"
     },
     "error": {
-      "ambiguous_identifier": "The region identifier and device tracker cannot be specified together.",
+      "ambiguous_identifier": "The region identifier and device tracker can not be specified together.",
       "attribute_not_found": "The required attributes 'Latitude' and 'Longitude' were not found in the specified device tracker.",
       "entity_not_found": "The specified device tracker entity was not found.",
       "invalid_identifier": "The specified region identifier / device tracker is invalid.",

homeassistant/components/ecowitt/entity.py

@@ -24,10 +24,11 @@ class EcowittEntity(Entity):
 
         self._attr_unique_id = f"{sensor.station.key}-{sensor.key}"
         self._attr_device_info = DeviceInfo(
-            identifiers={(DOMAIN, sensor.station.key)},
+            identifiers={
+                (DOMAIN, sensor.station.key),
+            },
             name=sensor.station.model,
             model=sensor.station.model,
-            manufacturer="Ecowitt",
             sw_version=sensor.station.version,
         )
 

homeassistant/components/ekeybionyx/config_flow.py

@@ -29,11 +29,9 @@ VALID_NAME_PATTERN = re.compile(r"^(?![\d\s])[\w\d \.]*[\w\d]$")
 
 
 class ConfigFlowEkeyApi(ekey_bionyxpy.AbstractAuth):
-    """Authentication implementation used during config flow, without refresh.
+    """ekey bionyx authentication before a ConfigEntry exists.
 
-    This exists to allow the config flow to use the API before it has fully
-    created a config entry required by OAuth2Session. This does not support
-    refreshing tokens, which is fine since it should have been just created.
+    This implementation directly provides the token without supporting refresh.
     """
 
     def __init__(

homeassistant/components/forecast_solar/__init__.py

@@ -2,26 +2,14 @@
 
 from __future__ import annotations
 
-from types import MappingProxyType
-
-from homeassistant.config_entries import ConfigSubentry
-from homeassistant.const import CONF_API_KEY, Platform
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryError
 
 from .const import (
-    CONF_AZIMUTH,
     CONF_DAMPING,
     CONF_DAMPING_EVENING,
     CONF_DAMPING_MORNING,
-    CONF_DECLINATION,
     CONF_MODULES_POWER,
-    DEFAULT_AZIMUTH,
-    DEFAULT_DAMPING,
-    DEFAULT_DECLINATION,
-    DEFAULT_MODULES_POWER,
-    DOMAIN,
-    SUBENTRY_TYPE_PLANE,
 )
 from .coordinator import ForecastSolarConfigEntry, ForecastSolarDataUpdateCoordinator
 
@@ -37,41 +25,14 @@ async def async_migrate_entry(
         new_options = entry.options.copy()
         new_options |= {
             CONF_MODULES_POWER: new_options.pop("modules power"),
-            CONF_DAMPING_MORNING: new_options.get(CONF_DAMPING, DEFAULT_DAMPING),
-            CONF_DAMPING_EVENING: new_options.pop(CONF_DAMPING, DEFAULT_DAMPING),
+            CONF_DAMPING_MORNING: new_options.get(CONF_DAMPING, 0.0),
+            CONF_DAMPING_EVENING: new_options.pop(CONF_DAMPING, 0.0),
         }
 
         hass.config_entries.async_update_entry(
             entry, data=entry.data, options=new_options, version=2
         )
 
-    if entry.version == 2:
-        # Migrate the main plane from options to a subentry
-        declination = entry.options.get(CONF_DECLINATION, DEFAULT_DECLINATION)
-        azimuth = entry.options.get(CONF_AZIMUTH, DEFAULT_AZIMUTH)
-        modules_power = entry.options.get(CONF_MODULES_POWER, DEFAULT_MODULES_POWER)
-
-        subentry = ConfigSubentry(
-            data=MappingProxyType(
-                {
-                    CONF_DECLINATION: declination,
-                    CONF_AZIMUTH: azimuth,
-                    CONF_MODULES_POWER: modules_power,
-                }
-            ),
-            subentry_type=SUBENTRY_TYPE_PLANE,
-            title=f"{declination}° / {azimuth}° / {modules_power}W",
-            unique_id=None,
-        )
-        hass.config_entries.async_add_subentry(entry, subentry)
-
-        new_options = dict(entry.options)
-        new_options.pop(CONF_DECLINATION, None)
-        new_options.pop(CONF_AZIMUTH, None)
-        new_options.pop(CONF_MODULES_POWER, None)
-
-        hass.config_entries.async_update_entry(entry, options=new_options, version=3)
-
     return True
 
 
@@ -79,19 +40,6 @@ async def async_setup_entry(
     hass: HomeAssistant, entry: ForecastSolarConfigEntry
 ) -> bool:
     """Set up Forecast.Solar from a config entry."""
-    plane_subentries = entry.get_subentries_of_type(SUBENTRY_TYPE_PLANE)
-    if not plane_subentries:
-        raise ConfigEntryError(
-            translation_domain=DOMAIN,
-            translation_key="no_plane",
-        )
-
-    if len(plane_subentries) > 1 and not entry.options.get(CONF_API_KEY):
-        raise ConfigEntryError(
-            translation_domain=DOMAIN,
-            translation_key="api_key_required",
-        )
-
     coordinator = ForecastSolarDataUpdateCoordinator(hass, entry)
     await coordinator.async_config_entry_first_refresh()
 
@@ -99,18 +47,9 @@ async def async_setup_entry(
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-    entry.async_on_unload(entry.add_update_listener(_async_update_listener))
-
     return True
 
 
-async def _async_update_listener(
-    hass: HomeAssistant, entry: ForecastSolarConfigEntry
-) -> None:
-    """Handle config entry updates (options or subentry changes)."""
-    hass.config_entries.async_schedule_reload(entry.entry_id)
-
-
 async def async_unload_entry(
     hass: HomeAssistant, entry: ForecastSolarConfigEntry
 ) -> bool:

homeassistant/components/forecast_solar/config_flow.py

@@ -11,13 +11,11 @@ from homeassistant.config_entries import (
     ConfigEntry,
     ConfigFlow,
     ConfigFlowResult,
-    ConfigSubentryFlow,
-    OptionsFlow,
-    SubentryFlowResult,
+    OptionsFlowWithReload,
 )
 from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE, CONF_NAME
 from homeassistant.core import callback
-from homeassistant.helpers import config_validation as cv, selector
+from homeassistant.helpers import config_validation as cv
 
 from .const import (
     CONF_AZIMUTH,
@@ -26,51 +24,16 @@ from .const import (
     CONF_DECLINATION,
     CONF_INVERTER_SIZE,
     CONF_MODULES_POWER,
-    DEFAULT_AZIMUTH,
-    DEFAULT_DAMPING,
-    DEFAULT_DECLINATION,
-    DEFAULT_MODULES_POWER,
     DOMAIN,
-    MAX_PLANES,
-    SUBENTRY_TYPE_PLANE,
 )
 
 RE_API_KEY = re.compile(r"^[a-zA-Z0-9]{16}$")
 
-PLANE_SCHEMA = vol.Schema(
-    {
-        vol.Required(CONF_DECLINATION): vol.All(
-            selector.NumberSelector(
-                selector.NumberSelectorConfig(
-                    min=0, max=90, step=1, mode=selector.NumberSelectorMode.BOX
-                ),
-            ),
-            vol.Coerce(int),
-        ),
-        vol.Required(CONF_AZIMUTH): vol.All(
-            selector.NumberSelector(
-                selector.NumberSelectorConfig(
-                    min=0, max=360, step=1, mode=selector.NumberSelectorMode.BOX
-                ),
-            ),
-            vol.Coerce(int),
-        ),
-        vol.Required(CONF_MODULES_POWER): vol.All(
-            selector.NumberSelector(
-                selector.NumberSelectorConfig(
-                    min=1, step=1, mode=selector.NumberSelectorMode.BOX
-                ),
-            ),
-            vol.Coerce(int),
-        ),
-    }
-)
-
 
 class ForecastSolarFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Forecast.Solar."""
 
-    VERSION = 3
+    VERSION = 2
 
     @staticmethod
     @callback
@@ -80,14 +43,6 @@ class ForecastSolarFlowHandler(ConfigFlow, domain=DOMAIN):
         """Get the options flow for this handler."""
         return ForecastSolarOptionFlowHandler()
 
-    @classmethod
-    @callback
-    def async_get_supported_subentry_types(
-        cls, config_entry: ConfigEntry
-    ) -> dict[str, type[ConfigSubentryFlow]]:
-        """Return subentries supported by this handler."""
-        return {SUBENTRY_TYPE_PLANE: PlaneSubentryFlowHandler}
-
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -99,112 +54,94 @@ class ForecastSolarFlowHandler(ConfigFlow, domain=DOMAIN):
                     CONF_LATITUDE: user_input[CONF_LATITUDE],
                     CONF_LONGITUDE: user_input[CONF_LONGITUDE],
                 },
-                subentries=[
-                    {
-                        "subentry_type": SUBENTRY_TYPE_PLANE,
-                        "data": {
-                            CONF_DECLINATION: user_input[CONF_DECLINATION],
-                            CONF_AZIMUTH: user_input[CONF_AZIMUTH],
-                            CONF_MODULES_POWER: user_input[CONF_MODULES_POWER],
-                        },
-                        "title": f"{user_input[CONF_DECLINATION]}° / {user_input[CONF_AZIMUTH]}° / {user_input[CONF_MODULES_POWER]}W",
-                        "unique_id": None,
-                    },
-                ],
+                options={
+                    CONF_AZIMUTH: user_input[CONF_AZIMUTH],
+                    CONF_DECLINATION: user_input[CONF_DECLINATION],
+                    CONF_MODULES_POWER: user_input[CONF_MODULES_POWER],
+                },
             )
 
         return self.async_show_form(
             step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                vol.Schema(
-                    {
-                        vol.Required(CONF_NAME): str,
-                        vol.Required(CONF_LATITUDE): cv.latitude,
-                        vol.Required(CONF_LONGITUDE): cv.longitude,
-                    }
-                ).extend(PLANE_SCHEMA.schema),
+            data_schema=vol.Schema(
                 {
-                    CONF_NAME: self.hass.config.location_name,
-                    CONF_LATITUDE: self.hass.config.latitude,
-                    CONF_LONGITUDE: self.hass.config.longitude,
-                    CONF_DECLINATION: DEFAULT_DECLINATION,
-                    CONF_AZIMUTH: DEFAULT_AZIMUTH,
-                    CONF_MODULES_POWER: DEFAULT_MODULES_POWER,
-                },
+                    vol.Required(
+                        CONF_NAME, default=self.hass.config.location_name
+                    ): str,
+                    vol.Required(
+                        CONF_LATITUDE, default=self.hass.config.latitude
+                    ): cv.latitude,
+                    vol.Required(
+                        CONF_LONGITUDE, default=self.hass.config.longitude
+                    ): cv.longitude,
+                    vol.Required(CONF_DECLINATION, default=25): vol.All(
+                        vol.Coerce(int), vol.Range(min=0, max=90)
+                    ),
+                    vol.Required(CONF_AZIMUTH, default=180): vol.All(
+                        vol.Coerce(int), vol.Range(min=0, max=360)
+                    ),
+                    vol.Required(CONF_MODULES_POWER): vol.All(
+                        vol.Coerce(int), vol.Range(min=1)
+                    ),
+                }
             ),
         )
 
 
-class ForecastSolarOptionFlowHandler(OptionsFlow):
+class ForecastSolarOptionFlowHandler(OptionsFlowWithReload):
     """Handle options."""
 
     async def async_step_init(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Manage the options."""
-        errors: dict[str, str] = {}
-        planes_count = len(
-            self.config_entry.get_subentries_of_type(SUBENTRY_TYPE_PLANE)
-        )
-
+        errors = {}
         if user_input is not None:
-            api_key = user_input.get(CONF_API_KEY)
-            if planes_count > 1 and not api_key:
-                errors[CONF_API_KEY] = "api_key_required"
-            elif api_key and RE_API_KEY.match(api_key) is None:
+            if (api_key := user_input.get(CONF_API_KEY)) and RE_API_KEY.match(
+                api_key
+            ) is None:
                 errors[CONF_API_KEY] = "invalid_api_key"
             else:
                 return self.async_create_entry(
                     title="", data=user_input | {CONF_API_KEY: api_key or None}
                 )
 
-        suggested_api_key = self.config_entry.options.get(CONF_API_KEY, "")
-
         return self.async_show_form(
             step_id="init",
             data_schema=vol.Schema(
                 {
-                    vol.Required(
+                    vol.Optional(
                         CONF_API_KEY,
-                        default=suggested_api_key,
-                    )
-                    if planes_count > 1
-                    else vol.Optional(
-                        CONF_API_KEY,
-                        description={"suggested_value": suggested_api_key},
+                        description={
+                            "suggested_value": self.config_entry.options.get(
+                                CONF_API_KEY, ""
+                            )
+                        },
                     ): str,
+                    vol.Required(
+                        CONF_DECLINATION,
+                        default=self.config_entry.options[CONF_DECLINATION],
+                    ): vol.All(vol.Coerce(int), vol.Range(min=0, max=90)),
+                    vol.Required(
+                        CONF_AZIMUTH,
+                        default=self.config_entry.options.get(CONF_AZIMUTH),
+                    ): vol.All(vol.Coerce(int), vol.Range(min=-0, max=360)),
+                    vol.Required(
+                        CONF_MODULES_POWER,
+                        default=self.config_entry.options[CONF_MODULES_POWER],
+                    ): vol.All(vol.Coerce(int), vol.Range(min=1)),
                     vol.Optional(
                         CONF_DAMPING_MORNING,
                         default=self.config_entry.options.get(
-                            CONF_DAMPING_MORNING, DEFAULT_DAMPING
+                            CONF_DAMPING_MORNING, 0.0
                         ),
-                    ): vol.All(
-                        selector.NumberSelector(
-                            selector.NumberSelectorConfig(
-                                min=0,
-                                max=1,
-                                step=0.01,
-                                mode=selector.NumberSelectorMode.BOX,
-                            ),
-                        ),
-                        vol.Coerce(float),
-                    ),
+                    ): vol.Coerce(float),
                     vol.Optional(
                         CONF_DAMPING_EVENING,
                         default=self.config_entry.options.get(
-                            CONF_DAMPING_EVENING, DEFAULT_DAMPING
+                            CONF_DAMPING_EVENING, 0.0
                         ),
-                    ): vol.All(
-                        selector.NumberSelector(
-                            selector.NumberSelectorConfig(
-                                min=0,
-                                max=1,
-                                step=0.01,
-                                mode=selector.NumberSelectorMode.BOX,
-                            ),
-                        ),
-                        vol.Coerce(float),
-                    ),
+                    ): vol.Coerce(float),
                     vol.Optional(
                         CONF_INVERTER_SIZE,
                         description={
@@ -212,89 +149,8 @@ class ForecastSolarOptionFlowHandler(OptionsFlow):
                                 CONF_INVERTER_SIZE
                             )
                         },
-                    ): vol.All(
-                        selector.NumberSelector(
-                            selector.NumberSelectorConfig(
-                                min=1,
-                                step=1,
-                                mode=selector.NumberSelectorMode.BOX,
-                            ),
-                        ),
-                        vol.Coerce(int),
-                    ),
+                    ): vol.Coerce(int),
                 }
             ),
             errors=errors,
         )
-
-
-class PlaneSubentryFlowHandler(ConfigSubentryFlow):
-    """Handle a subentry flow for adding/editing a plane."""
-
-    async def async_step_user(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle the user step to add a new plane."""
-        entry = self._get_entry()
-        planes_count = len(entry.get_subentries_of_type(SUBENTRY_TYPE_PLANE))
-        if planes_count >= MAX_PLANES:
-            return self.async_abort(reason="max_planes")
-        if planes_count >= 1 and not entry.options.get(CONF_API_KEY):
-            return self.async_abort(reason="api_key_required")
-
-        if user_input is not None:
-            return self.async_create_entry(
-                title=f"{user_input[CONF_DECLINATION]}° / {user_input[CONF_AZIMUTH]}° / {user_input[CONF_MODULES_POWER]}W",
-                data={
-                    CONF_DECLINATION: user_input[CONF_DECLINATION],
-                    CONF_AZIMUTH: user_input[CONF_AZIMUTH],
-                    CONF_MODULES_POWER: user_input[CONF_MODULES_POWER],
-                },
-            )
-
-        return self.async_show_form(
-            step_id="user",
-            data_schema=self.add_suggested_values_to_schema(
-                PLANE_SCHEMA,
-                {
-                    CONF_DECLINATION: DEFAULT_DECLINATION,
-                    CONF_AZIMUTH: DEFAULT_AZIMUTH,
-                    CONF_MODULES_POWER: DEFAULT_MODULES_POWER,
-                },
-            ),
-        )
-
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> SubentryFlowResult:
-        """Handle reconfiguration of an existing plane."""
-        subentry = self._get_reconfigure_subentry()
-
-        if user_input is not None:
-            entry = self._get_entry()
-            if self._async_update(
-                entry,
-                subentry,
-                data={
-                    CONF_DECLINATION: user_input[CONF_DECLINATION],
-                    CONF_AZIMUTH: user_input[CONF_AZIMUTH],
-                    CONF_MODULES_POWER: user_input[CONF_MODULES_POWER],
-                },
-                title=f"{user_input[CONF_DECLINATION]}° / {user_input[CONF_AZIMUTH]}° / {user_input[CONF_MODULES_POWER]}W",
-            ):
-                if not entry.update_listeners:
-                    self.hass.config_entries.async_schedule_reload(entry.entry_id)
-
-            return self.async_abort(reason="reconfigure_successful")
-
-        return self.async_show_form(
-            step_id="reconfigure",
-            data_schema=self.add_suggested_values_to_schema(
-                PLANE_SCHEMA,
-                {
-                    CONF_DECLINATION: subentry.data[CONF_DECLINATION],
-                    CONF_AZIMUTH: subentry.data[CONF_AZIMUTH],
-                    CONF_MODULES_POWER: subentry.data[CONF_MODULES_POWER],
-                },
-            ),
-        )

homeassistant/components/forecast_solar/const.py

@@ -14,9 +14,3 @@ CONF_DAMPING = "damping"
 CONF_DAMPING_MORNING = "damping_morning"
 CONF_DAMPING_EVENING = "damping_evening"
 CONF_INVERTER_SIZE = "inverter_size"
-DEFAULT_DECLINATION = 25
-DEFAULT_AZIMUTH = 180
-DEFAULT_MODULES_POWER = 10000
-DEFAULT_DAMPING = 0.0
-MAX_PLANES = 4
-SUBENTRY_TYPE_PLANE = "plane"

homeassistant/components/forecast_solar/coordinator.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from datetime import timedelta
 
-from forecast_solar import Estimate, ForecastSolar, ForecastSolarConnectionError, Plane
+from forecast_solar import Estimate, ForecastSolar, ForecastSolarConnectionError
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE
@@ -19,10 +19,8 @@ from .const import (
     CONF_DECLINATION,
     CONF_INVERTER_SIZE,
     CONF_MODULES_POWER,
-    DEFAULT_DAMPING,
     DOMAIN,
     LOGGER,
-    SUBENTRY_TYPE_PLANE,
 )
 
 type ForecastSolarConfigEntry = ConfigEntry[ForecastSolarDataUpdateCoordinator]
@@ -32,7 +30,6 @@ class ForecastSolarDataUpdateCoordinator(DataUpdateCoordinator[Estimate]):
     """The Forecast.Solar Data Update Coordinator."""
 
     config_entry: ForecastSolarConfigEntry
-    forecast: ForecastSolar
 
     def __init__(self, hass: HomeAssistant, entry: ForecastSolarConfigEntry) -> None:
         """Initialize the Forecast.Solar coordinator."""
@@ -46,34 +43,17 @@ class ForecastSolarDataUpdateCoordinator(DataUpdateCoordinator[Estimate]):
         ) is not None and inverter_size > 0:
             inverter_size = inverter_size / 1000
 
-        # Build the list of planes from subentries.
-        plane_subentries = entry.get_subentries_of_type(SUBENTRY_TYPE_PLANE)
-
-        # The first plane subentry is the main plane
-        main_plane = plane_subentries[0]
-
-        # Additional planes
-        planes: list[Plane] = [
-            Plane(
-                declination=subentry.data[CONF_DECLINATION],
-                azimuth=(subentry.data[CONF_AZIMUTH] - 180),
-                kwp=(subentry.data[CONF_MODULES_POWER] / 1000),
-            )
-            for subentry in plane_subentries[1:]
-        ]
-
         self.forecast = ForecastSolar(
             api_key=api_key,
             session=async_get_clientsession(hass),
             latitude=entry.data[CONF_LATITUDE],
             longitude=entry.data[CONF_LONGITUDE],
-            declination=main_plane.data[CONF_DECLINATION],
-            azimuth=(main_plane.data[CONF_AZIMUTH] - 180),
-            kwp=(main_plane.data[CONF_MODULES_POWER] / 1000),
-            damping_morning=entry.options.get(CONF_DAMPING_MORNING, DEFAULT_DAMPING),
-            damping_evening=entry.options.get(CONF_DAMPING_EVENING, DEFAULT_DAMPING),
+            declination=entry.options[CONF_DECLINATION],
+            azimuth=(entry.options[CONF_AZIMUTH] - 180),
+            kwp=(entry.options[CONF_MODULES_POWER] / 1000),
+            damping_morning=entry.options.get(CONF_DAMPING_MORNING, 0.0),
+            damping_evening=entry.options.get(CONF_DAMPING_EVENING, 0.0),
             inverter=inverter_size,
-            planes=planes,
         )
 
         # Free account have a resolution of 1 hour, using that as the default

homeassistant/components/forecast_solar/diagnostics.py

@@ -28,13 +28,6 @@ async def async_get_config_entry_diagnostics(
             "title": entry.title,
             "data": async_redact_data(entry.data, TO_REDACT),
             "options": async_redact_data(entry.options, TO_REDACT),
-            "subentries": [
-                {
-                    "data": dict(subentry.data),
-                    "title": subentry.title,
-                }
-                for subentry in entry.subentries.values()
-            ],
         },
         "data": {
             "energy_production_today": coordinator.data.energy_production_today,

homeassistant/components/forecast_solar/strings.json

@@ -14,37 +14,6 @@
       }
     }
   },
-  "config_subentries": {
-    "plane": {
-      "abort": {
-        "api_key_required": "An API key is required to add more than one plane. You can configure it in the integration options.",
-        "max_planes": "You can add a maximum of 4 planes.",
-        "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
-      },
-      "entry_type": "Plane",
-      "initiate_flow": {
-        "user": "Add plane"
-      },
-      "step": {
-        "reconfigure": {
-          "data": {
-            "azimuth": "[%key:component::forecast_solar::config::step::user::data::azimuth%]",
-            "declination": "[%key:component::forecast_solar::config::step::user::data::declination%]",
-            "modules_power": "[%key:component::forecast_solar::config::step::user::data::modules_power%]"
-          },
-          "description": "Edit the solar plane configuration."
-        },
-        "user": {
-          "data": {
-            "azimuth": "[%key:component::forecast_solar::config::step::user::data::azimuth%]",
-            "declination": "[%key:component::forecast_solar::config::step::user::data::declination%]",
-            "modules_power": "[%key:component::forecast_solar::config::step::user::data::modules_power%]"
-          },
-          "description": "Add a solar plane. Multiple planes are supported with a Forecast.Solar API subscription."
-        }
-      }
-    }
-  },
   "entity": {
     "sensor": {
       "energy_current_hour": {
@@ -82,26 +51,20 @@
       }
     }
   },
-  "exceptions": {
-    "api_key_required": {
-      "message": "An API key is required when more than one plane is configured"
-    },
-    "no_plane": {
-      "message": "No plane configured, cannot set up Forecast.Solar"
-    }
-  },
   "options": {
     "error": {
-      "api_key_required": "An API key is required to add more than one plane. You can configure it in the integration options.",
       "invalid_api_key": "[%key:common::config_flow::error::invalid_api_key%]"
     },
     "step": {
       "init": {
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]",
+          "azimuth": "[%key:component::forecast_solar::config::step::user::data::azimuth%]",
           "damping_evening": "Damping factor: adjusts the results in the evening",
           "damping_morning": "Damping factor: adjusts the results in the morning",
-          "inverter_size": "Inverter size (Watt)"
+          "declination": "[%key:component::forecast_solar::config::step::user::data::declination%]",
+          "inverter_size": "Inverter size (Watt)",
+          "modules_power": "[%key:component::forecast_solar::config::step::user::data::modules_power%]"
         },
         "description": "These values allow tweaking the Forecast.Solar result. Please refer to the documentation if a field is unclear."
       }

homeassistant/components/fritz/image.py

@@ -10,11 +10,9 @@ from requests.exceptions import RequestException
 from homeassistant.components.image import ImageEntity
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
-from homeassistant.helpers import entity_registry as er
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import dt as dt_util, slugify
 
-from .const import DOMAIN, Platform
 from .coordinator import AvmWrapper, FritzConfigEntry
 from .entity import FritzBoxBaseEntity
 
@@ -24,32 +22,6 @@ _LOGGER = logging.getLogger(__name__)
 PARALLEL_UPDATES = 0
 
 
-async def _migrate_to_new_unique_id(
-    hass: HomeAssistant, avm_wrapper: AvmWrapper, ssid: str
-) -> None:
-    """Migrate old unique id to new unique id."""
-
-    old_unique_id = slugify(f"{avm_wrapper.unique_id}-{ssid}-qr-code")
-    new_unique_id = f"{avm_wrapper.unique_id}-guest_wifi_qr_code"
-
-    entity_registry = er.async_get(hass)
-    entity_id = entity_registry.async_get_entity_id(
-        Platform.IMAGE,
-        DOMAIN,
-        old_unique_id,
-    )
-
-    if entity_id is None:
-        return
-
-    entity_registry.async_update_entity(entity_id, new_unique_id=new_unique_id)
-    _LOGGER.debug(
-        "Migrating guest Wi-Fi image unique_id from [%s] to [%s]",
-        old_unique_id,
-        new_unique_id,
-    )
-
-
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: FritzConfigEntry,
@@ -62,8 +34,6 @@ async def async_setup_entry(
         avm_wrapper.fritz_guest_wifi.get_info
     )
 
-    await _migrate_to_new_unique_id(hass, avm_wrapper, guest_wifi_info["NewSSID"])
-
     async_add_entities(
         [
             FritzGuestWifiQRImage(
@@ -90,7 +60,7 @@ class FritzGuestWifiQRImage(FritzBoxBaseEntity, ImageEntity):
     ) -> None:
         """Initialize the image entity."""
         self._attr_name = ssid
-        self._attr_unique_id = f"{avm_wrapper.unique_id}-guest_wifi_qr_code"
+        self._attr_unique_id = slugify(f"{avm_wrapper.unique_id}-{ssid}-qr-code")
         self._current_qr_bytes: bytes | None = None
         super().__init__(avm_wrapper, device_friendly_name)
         ImageEntity.__init__(self, hass)

homeassistant/components/frontend/manifest.json

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

homeassistant/components/google_sheets/strings.json

@@ -68,7 +68,7 @@
           "name": "Worksheet"
         }
       },
-      "name": "Append data to Google sheet"
+      "name": "Append to sheet"
     },
     "get_sheet": {
       "description": "Gets data from a worksheet in Google Sheets.",
@@ -86,7 +86,7 @@
           "name": "[%key:component::google_sheets::services::append_sheet::fields::worksheet::name%]"
         }
       },
-      "name": "Get data from Google sheet"
+      "name": "Get data from sheet"
     }
   }
 }

homeassistant/components/growatt_server/config_flow.py

@@ -8,7 +8,7 @@ import growattServer
 import requests
 import voluptuous as vol
 
-from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.const import (
     CONF_NAME,
     CONF_PASSWORD,
@@ -64,16 +64,6 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
             menu_options=["password_auth", "token_auth"],
         )
 
-    async def async_step_reconfigure(
-        self, user_input: dict[str, Any] | None = None
-    ) -> ConfigFlowResult:
-        """Handle reconfiguration."""
-        return await self._async_step_credentials(
-            step_id="reconfigure",
-            entry=self._get_reconfigure_entry(),
-            user_input=user_input,
-        )
-
     async def async_step_reauth(self, _: Mapping[str, Any]) -> ConfigFlowResult:
         """Handle reauth."""
         return await self.async_step_reauth_confirm()
@@ -82,23 +72,11 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle reauth confirmation."""
-        return await self._async_step_credentials(
-            step_id="reauth_confirm",
-            entry=self._get_reauth_entry(),
-            user_input=user_input,
-        )
-
-    async def _async_step_credentials(
-        self,
-        step_id: str,
-        entry: ConfigEntry,
-        user_input: dict[str, Any] | None,
-    ) -> ConfigFlowResult:
-        """Handle credential update for both reauth and reconfigure."""
         errors: dict[str, str] = {}
+        reauth_entry = self._get_reauth_entry()
 
         if user_input is not None:
-            auth_type = entry.data.get(CONF_AUTH_TYPE)
+            auth_type = reauth_entry.data.get(CONF_AUTH_TYPE)
 
             if auth_type == AUTH_PASSWORD:
                 server_url = SERVER_URLS_NAMES[user_input[CONF_REGION]]
@@ -113,19 +91,17 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
                         api.login, user_input[CONF_USERNAME], user_input[CONF_PASSWORD]
                     )
                 except requests.exceptions.RequestException as ex:
-                    _LOGGER.debug("Network error during credential update: %s", ex)
+                    _LOGGER.debug("Network error during reauth login: %s", ex)
                     errors["base"] = ERROR_CANNOT_CONNECT
                 except (ValueError, KeyError, TypeError, AttributeError) as ex:
-                    _LOGGER.debug(
-                        "Invalid response format during credential update: %s", ex
-                    )
+                    _LOGGER.debug("Invalid response format during reauth login: %s", ex)
                     errors["base"] = ERROR_CANNOT_CONNECT
                 else:
                     if not isinstance(login_response, dict):
                         errors["base"] = ERROR_CANNOT_CONNECT
                     elif login_response.get("success"):
                         return self.async_update_reload_and_abort(
-                            entry,
+                            reauth_entry,
                             data_updates={
                                 CONF_USERNAME: user_input[CONF_USERNAME],
                                 CONF_PASSWORD: user_input[CONF_PASSWORD],
@@ -145,26 +121,28 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
                 try:
                     await self.hass.async_add_executor_job(api.plant_list)
                 except requests.exceptions.RequestException as ex:
-                    _LOGGER.debug("Network error during credential update: %s", ex)
+                    _LOGGER.debug(
+                        "Network error during reauth token validation: %s", ex
+                    )
                     errors["base"] = ERROR_CANNOT_CONNECT
                 except growattServer.GrowattV1ApiError as err:
                     if err.error_code == V1_API_ERROR_NO_PRIVILEGE:
                         errors["base"] = ERROR_INVALID_AUTH
                     else:
                         _LOGGER.debug(
-                            "Growatt V1 API error during credential update: %s (Code: %s)",
+                            "Growatt V1 API error during reauth: %s (Code: %s)",
                             err.error_msg or str(err),
                             err.error_code,
                         )
                         errors["base"] = ERROR_CANNOT_CONNECT
                 except (ValueError, KeyError, TypeError, AttributeError) as ex:
                     _LOGGER.debug(
-                        "Invalid response format during credential update: %s", ex
+                        "Invalid response format during reauth token validation: %s", ex
                     )
                     errors["base"] = ERROR_CANNOT_CONNECT
                 else:
                     return self.async_update_reload_and_abort(
-                        entry,
+                        reauth_entry,
                         data_updates={
                             CONF_TOKEN: user_input[CONF_TOKEN],
                             CONF_URL: server_url,
@@ -173,19 +151,19 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
 
         # Determine the current region key from the stored config value.
         # Legacy entries may store the region key directly; newer entries store the URL.
-        stored_url = entry.data.get(CONF_URL, "")
+        stored_url = reauth_entry.data.get(CONF_URL, "")
         if stored_url in SERVER_URLS_NAMES:
             current_region = stored_url
         else:
             current_region = _URL_TO_REGION.get(stored_url, DEFAULT_URL)
 
-        auth_type = entry.data.get(CONF_AUTH_TYPE)
+        auth_type = reauth_entry.data.get(CONF_AUTH_TYPE)
         if auth_type == AUTH_PASSWORD:
             data_schema = vol.Schema(
                 {
                     vol.Required(
                         CONF_USERNAME,
-                        default=entry.data.get(CONF_USERNAME),
+                        default=reauth_entry.data.get(CONF_USERNAME),
                     ): str,
                     vol.Required(CONF_PASSWORD): str,
                     vol.Required(CONF_REGION, default=current_region): SelectSelector(
@@ -211,18 +189,8 @@ class GrowattServerConfigFlow(ConfigFlow, domain=DOMAIN):
         else:
             return self.async_abort(reason=ERROR_CANNOT_CONNECT)
 
-        if user_input is not None:
-            data_schema = self.add_suggested_values_to_schema(
-                data_schema,
-                {
-                    key: value
-                    for key, value in user_input.items()
-                    if key not in (CONF_PASSWORD, CONF_TOKEN)
-                },
-            )
-
         return self.async_show_form(
-            step_id=step_id,
+            step_id="reauth_confirm",
             data_schema=data_schema,
             errors=errors,
         )

homeassistant/components/growatt_server/quality_scale.yaml

@@ -50,7 +50,7 @@ rules:
   entity-translations: done
   exception-translations: done
   icon-translations: done
-  reconfiguration-flow: done
+  reconfiguration-flow: todo
   repair-issues:
     status: exempt
     comment: Integration does not raise repairable issues.

homeassistant/components/growatt_server/strings.json

@@ -4,8 +4,7 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "no_plants": "No plants have been found on this account",
-      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
-      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "Cannot connect to Growatt servers. Please check your internet connection and try again.",
@@ -50,22 +49,6 @@
         "description": "Re-enter your credentials to continue using this integration.",
         "title": "Re-authenticate with Growatt"
       },
-      "reconfigure": {
-        "data": {
-          "password": "[%key:common::config_flow::data::password%]",
-          "region": "[%key:component::growatt_server::config::step::password_auth::data::region%]",
-          "token": "[%key:component::growatt_server::config::step::token_auth::data::token%]",
-          "username": "[%key:common::config_flow::data::username%]"
-        },
-        "data_description": {
-          "password": "[%key:component::growatt_server::config::step::password_auth::data_description::password%]",
-          "region": "[%key:component::growatt_server::config::step::password_auth::data_description::region%]",
-          "token": "[%key:component::growatt_server::config::step::token_auth::data_description::token%]",
-          "username": "[%key:component::growatt_server::config::step::password_auth::data_description::username%]"
-        },
-        "description": "Update your credentials to continue using this integration.",
-        "title": "Reconfigure Growatt"
-      },
       "token_auth": {
         "data": {
           "region": "[%key:component::growatt_server::config::step::password_auth::data::region%]",

homeassistant/components/holiday/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/holiday",
   "iot_class": "local_polling",
-  "requirements": ["holidays==0.93", "babel==2.15.0"]
+  "requirements": ["holidays==0.84", "babel==2.15.0"]
 }

homeassistant/components/homekit/type_thermostats.py

@@ -49,21 +49,14 @@ from homeassistant.components.climate import (
     HVACMode,
 )
 from homeassistant.components.water_heater import (
-    ATTR_OPERATION_LIST,
-    ATTR_OPERATION_MODE,
     DOMAIN as WATER_HEATER_DOMAIN,
-    SERVICE_SET_OPERATION_MODE,
     SERVICE_SET_TEMPERATURE as SERVICE_SET_TEMPERATURE_WATER_HEATER,
-    WaterHeaterEntityFeature,
 )
 from homeassistant.const import (
     ATTR_ENTITY_ID,
     ATTR_SUPPORTED_FEATURES,
     ATTR_TEMPERATURE,
     PERCENTAGE,
-    SERVICE_TURN_OFF,
-    SERVICE_TURN_ON,
-    STATE_OFF,
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
     UnitOfTemperature,
@@ -752,7 +745,6 @@ class WaterHeater(HomeAccessory):
             (
                 ATTR_MAX_TEMP,
                 ATTR_MIN_TEMP,
-                ATTR_OPERATION_LIST,
             )
         )
         self._unit = self.hass.config.units.temperature_unit
@@ -760,20 +752,6 @@ class WaterHeater(HomeAccessory):
         assert state
         min_temp, max_temp = self.get_temperature_range(state)
 
-        features = state.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
-        operation_list = state.attributes.get(ATTR_OPERATION_LIST) or []
-        self._supports_on_off = bool(features & WaterHeaterEntityFeature.ON_OFF)
-        self._supports_operation_mode = bool(
-            features & WaterHeaterEntityFeature.OPERATION_MODE
-        )
-        self._off_mode_available = self._supports_on_off or (
-            self._supports_operation_mode and STATE_OFF in operation_list
-        )
-
-        valid_modes = dict(HC_HOMEKIT_VALID_MODES_WATER_HEATER)
-        if self._off_mode_available:
-            valid_modes["Off"] = HC_HEAT_COOL_OFF
-
         serv_thermostat = self.add_preload_service(SERV_THERMOSTAT)
 
         self.char_current_heat_cool = serv_thermostat.configure_char(
@@ -783,7 +761,7 @@ class WaterHeater(HomeAccessory):
             CHAR_TARGET_HEATING_COOLING,
             value=1,
             setter_callback=self.set_heat_cool,
-            valid_values=valid_modes,
+            valid_values=HC_HOMEKIT_VALID_MODES_WATER_HEATER,
         )
 
         self.char_current_temp = serv_thermostat.configure_char(
@@ -817,48 +795,8 @@ class WaterHeater(HomeAccessory):
     def set_heat_cool(self, value: int) -> None:
         """Change operation mode to value if call came from HomeKit."""
         _LOGGER.debug("%s: Set heat-cool to %d", self.entity_id, value)
-        params: dict[str, Any] = {ATTR_ENTITY_ID: self.entity_id}
-        if value == HC_HEAT_COOL_OFF:
-            if self._supports_on_off:
-                self.async_call_service(
-                    WATER_HEATER_DOMAIN, SERVICE_TURN_OFF, params, "off"
-                )
-            elif self._off_mode_available and self._supports_operation_mode:
-                params[ATTR_OPERATION_MODE] = STATE_OFF
-                self.async_call_service(
-                    WATER_HEATER_DOMAIN,
-                    SERVICE_SET_OPERATION_MODE,
-                    params,
-                    STATE_OFF,
-                )
-            else:
-                self.char_target_heat_cool.set_value(HC_HEAT_COOL_HEAT)
-        elif value == HC_HEAT_COOL_HEAT:
-            if self._supports_on_off:
-                self.async_call_service(
-                    WATER_HEATER_DOMAIN, SERVICE_TURN_ON, params, "on"
-                )
-            elif self._off_mode_available and self._supports_operation_mode:
-                state = self.hass.states.get(self.entity_id)
-                if not state:
-                    return
-                current_operation_mode = state.attributes.get(ATTR_OPERATION_MODE)
-                if current_operation_mode and current_operation_mode != STATE_OFF:
-                    # Already in a non-off operation mode; do not change it.
-                    return
-                operation_list = state.attributes.get(ATTR_OPERATION_LIST) or []
-                for mode in operation_list:
-                    if mode != STATE_OFF:
-                        params[ATTR_OPERATION_MODE] = mode
-                        self.async_call_service(
-                            WATER_HEATER_DOMAIN,
-                            SERVICE_SET_OPERATION_MODE,
-                            params,
-                            mode,
-                        )
-                        break
-        else:
-            self.char_target_heat_cool.set_value(HC_HEAT_COOL_HEAT)
+        if HC_HOMEKIT_TO_HASS[value] != HVACMode.HEAT:
+            self.char_target_heat_cool.set_value(1)  # Heat
 
     def set_target_temperature(self, value: float) -> None:
         """Set target temperature to value if call came from HomeKit."""
@@ -891,12 +829,7 @@ class WaterHeater(HomeAccessory):
 
         # Update target operation mode
         if new_state.state:
-            if new_state.state == STATE_OFF and self._off_mode_available:
-                self.char_target_heat_cool.set_value(HC_HEAT_COOL_OFF)
-                self.char_current_heat_cool.set_value(HC_HEAT_COOL_OFF)
-            else:
-                self.char_target_heat_cool.set_value(HC_HEAT_COOL_HEAT)
-                self.char_current_heat_cool.set_value(HC_HEAT_COOL_HEAT)
+            self.char_target_heat_cool.set_value(1)  # Heat
 
 
 def _get_temperature_range_from_state(

homeassistant/components/hydrawise/entity.py

@@ -69,10 +69,6 @@ class HydrawiseEntity(CoordinatorEntity[HydrawiseDataUpdateCoordinator]):
     @callback
     def _handle_coordinator_update(self) -> None:
         """Get the latest data and updates the state."""
-        # Guard against updates arriving after the controller has been removed
-        # but before the entity has been unsubscribed from the coordinator.
-        if self.controller.id not in self.coordinator.data.controllers:
-            return
         self.controller = self.coordinator.data.controllers[self.controller.id]
         self._update_attrs()
         super()._handle_coordinator_update()

homeassistant/components/hypontech/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "bronze",
-  "requirements": ["hyponcloud==0.9.3"]
+  "requirements": ["hyponcloud==0.9.0"]
 }

homeassistant/components/kaleidescape/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/kaleidescape",
   "integration_type": "device",
   "iot_class": "local_push",
-  "requirements": ["pykaleidescape==1.1.5"],
+  "requirements": ["pykaleidescape==1.1.4"],
   "ssdp": [
     {
       "deviceType": "schemas-upnp-org:device:Basic:1",

homeassistant/components/kitchen_sink/strings.json

@@ -72,7 +72,7 @@
     "cold_tea": {
       "fix_flow": {
         "abort": {
-          "not_tea_time": "Cannot reheat the tea at this time"
+          "not_tea_time": "Can not re-heat the tea at this time"
         },
         "step": {}
       },

homeassistant/components/lannouncer/notify.py

@@ -2,29 +2,111 @@
 
 from __future__ import annotations
 
+import logging
+import socket
+from typing import Any
+from urllib.parse import urlencode
+
 import voluptuous as vol
 
-from homeassistant.components.notify import PLATFORM_SCHEMA as NOTIFY_PLATFORM_SCHEMA
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers import issue_registry as ir
+from homeassistant.components.notify import (
+    ATTR_DATA,
+    PLATFORM_SCHEMA as NOTIFY_PLATFORM_SCHEMA,
+    BaseNotificationService,
+)
+from homeassistant.const import CONF_HOST, CONF_PORT
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, issue_registry as ir
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 DOMAIN = "lannouncer"
 
-PLATFORM_SCHEMA = NOTIFY_PLATFORM_SCHEMA.extend({}, extra=vol.ALLOW_EXTRA)
+ATTR_METHOD = "method"
+ATTR_METHOD_DEFAULT = "speak"
+ATTR_METHOD_ALLOWED = ["speak", "alarm"]
+
+DEFAULT_PORT = 1035
+
+PLATFORM_SCHEMA = NOTIFY_PLATFORM_SCHEMA.extend(
+    {
+        vol.Required(CONF_HOST): cv.string,
+        vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
+    }
+)
+
+_LOGGER = logging.getLogger(__name__)
 
 
-async def async_get_service(
+def get_service(
     hass: HomeAssistant,
     config: ConfigType,
     discovery_info: DiscoveryInfoType | None = None,
-) -> None:
+) -> LannouncerNotificationService:
     """Get the Lannouncer notification service."""
-    ir.async_create_issue(
-        hass,
-        DOMAIN,
-        DOMAIN,
-        is_fixable=False,
-        severity=ir.IssueSeverity.ERROR,
-        translation_key="integration_removed",
-    )
+
+    @callback
+    def _async_create_issue() -> None:
+        """Create issue for removed integration."""
+        ir.async_create_issue(
+            hass,
+            DOMAIN,
+            "integration_removed",
+            is_fixable=False,
+            breaks_in_ha_version="2026.3.0",
+            severity=ir.IssueSeverity.WARNING,
+            translation_key="integration_removed",
+        )
+
+    hass.add_job(_async_create_issue)
+
+    host = config.get(CONF_HOST)
+    port = config.get(CONF_PORT)
+
+    return LannouncerNotificationService(hass, host, port)
+
+
+class LannouncerNotificationService(BaseNotificationService):
+    """Implementation of a notification service for Lannouncer."""
+
+    def __init__(self, hass, host, port):
+        """Initialize the service."""
+        self._hass = hass
+        self._host = host
+        self._port = port
+
+    def send_message(self, message: str = "", **kwargs: Any) -> None:
+        """Send a message to Lannouncer."""
+        data = kwargs.get(ATTR_DATA)
+        if data is not None and ATTR_METHOD in data:
+            method = data.get(ATTR_METHOD)
+        else:
+            method = ATTR_METHOD_DEFAULT
+
+        if method not in ATTR_METHOD_ALLOWED:
+            _LOGGER.error("Unknown method %s", method)
+            return
+
+        cmd = urlencode({method: message})
+
+        try:
+            # Open socket
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(10)
+            sock.connect((self._host, self._port))
+
+            # Send message
+            _LOGGER.debug("Sending message: %s", cmd)
+            sock.sendall(cmd.encode())
+            sock.sendall(b"&@DONE@\n")
+
+            # Check response
+            buffer = sock.recv(1024)
+            if buffer != b"LANnouncer: OK":
+                _LOGGER.error("Error sending data to Lannnouncer: %s", buffer.decode())
+
+            # Close socket
+            sock.close()
+        except socket.gaierror:
+            _LOGGER.error("Unable to connect to host %s", self._host)
+        except OSError:
+            _LOGGER.exception("Failed to send data to Lannnouncer")

homeassistant/components/lannouncer/strings.json

@@ -1,8 +1,8 @@
 {
   "issues": {
     "integration_removed": {
-      "description": "The LANnouncer integration has been removed from Home Assistant because the LANnouncer Android app is no longer available.\n\nTo resolve this issue:\n1. Remove the LANnouncer integration from your `configuration.yaml`.\n2. Restart the Home Assistant instance.\n\nAfter removal, this issue will disappear.",
-      "title": "LANnouncer integration has been removed"
+      "description": "The LANnouncer Android app is no longer available, so this integration has been deprecated and will be removed in a future release.\n\nTo resolve this issue:\n1. Remove the LANnouncer integration from your `configuration.yaml`.\n2. Restart the Home Assistant instance.\n\nAfter removal, this issue will disappear.",
+      "title": "LANnouncer integration is deprecated"
     }
   }
 }

homeassistant/components/local_file/strings.json

@@ -4,7 +4,7 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_account%]"
     },
     "error": {
-      "not_readable_path": "The provided path to the file cannot be read"
+      "not_readable_path": "The provided path to the file can not be read"
     },
     "step": {
       "user": {

homeassistant/components/matter/climate.py

@@ -132,7 +132,6 @@ SUPPORT_DRY_MODE_DEVICES: set[tuple[int, int]] = {
     (0x1209, 0x8027),
     (0x1209, 0x8028),
     (0x1209, 0x8029),
-    (0x138C, 0x0101),
 }
 
 SUPPORT_FAN_MODE_DEVICES: set[tuple[int, int]] = {
@@ -173,7 +172,6 @@ SUPPORT_FAN_MODE_DEVICES: set[tuple[int, int]] = {
     (0x1209, 0x8028),
     (0x1209, 0x8029),
     (0x131A, 0x1000),
-    (0x138C, 0x0101),
 }
 
 SystemModeEnum = clusters.Thermostat.Enums.SystemModeEnum

homeassistant/components/matter/fan.py

@@ -323,11 +323,7 @@ DISCOVERY_SCHEMAS = [
         required_attributes=(
             clusters.FanControl.Attributes.FanMode,
             clusters.FanControl.Attributes.PercentCurrent,
-            clusters.FanControl.Attributes.PercentSetting,
         ),
-        # PercentSetting SHALL be null when FanMode is Auto (spec 4.4.6.3),
-        # so allow null values to not block discovery in that state.
-        allow_none_value=True,
         optional_attributes=(
             clusters.FanControl.Attributes.SpeedSetting,
             clusters.FanControl.Attributes.RockSetting,

homeassistant/components/matter/number.py

@@ -399,47 +399,6 @@ DISCOVERY_SCHEMAS = [
         ),
         entity_class=MatterNumber,
         required_attributes=(clusters.OccupancySensing.Attributes.HoldTime,),
-        # HoldTime is shared by PIR-specific numbers as a required attribute.
-        # Keep discovery open so this generic schema does not block them.
-        allow_multi=True,
-    ),
-    MatterDiscoverySchema(
-        platform=Platform.NUMBER,
-        entity_description=MatterNumberEntityDescription(
-            key="OccupancySensingPIRUnoccupiedToOccupiedDelay",
-            entity_category=EntityCategory.CONFIG,
-            translation_key="detection_delay",
-            native_max_value=65534,
-            native_min_value=0,
-            native_unit_of_measurement=UnitOfTime.SECONDS,
-            mode=NumberMode.BOX,
-        ),
-        entity_class=MatterNumber,
-        required_attributes=(
-            clusters.OccupancySensing.Attributes.PIRUnoccupiedToOccupiedDelay,
-            # This attribute is mandatory when the PIRUnoccupiedToOccupiedDelay is present
-            clusters.OccupancySensing.Attributes.HoldTime,
-        ),
-        featuremap_contains=clusters.OccupancySensing.Bitmaps.Feature.kPassiveInfrared,
-        allow_multi=True,
-    ),
-    MatterDiscoverySchema(
-        platform=Platform.NUMBER,
-        entity_description=MatterNumberEntityDescription(
-            key="OccupancySensingPIRUnoccupiedToOccupiedThreshold",
-            entity_category=EntityCategory.CONFIG,
-            translation_key="detection_threshold",
-            native_max_value=254,
-            native_min_value=1,
-            mode=NumberMode.BOX,
-        ),
-        entity_class=MatterNumber,
-        required_attributes=(
-            clusters.OccupancySensing.Attributes.PIRUnoccupiedToOccupiedThreshold,
-            clusters.OccupancySensing.Attributes.HoldTime,
-        ),
-        featuremap_contains=clusters.OccupancySensing.Bitmaps.Feature.kPassiveInfrared,
-        allow_multi=True,
     ),
     MatterDiscoverySchema(
         platform=Platform.NUMBER,

homeassistant/components/matter/strings.json

@@ -223,12 +223,6 @@
       "cook_time": {
         "name": "Cooking time"
       },
-      "detection_delay": {
-        "name": "Detection delay"
-      },
-      "detection_threshold": {
-        "name": "Detection threshold"
-      },
       "hold_time": {
         "name": "Hold time"
       },

homeassistant/components/matter/water_heater.py

@@ -168,15 +168,10 @@ class MatterWaterHeater(MatterEntity, WaterHeaterEntity):
         self._attr_target_temperature = self._get_temperature_in_degrees(
             clusters.Thermostat.Attributes.OccupiedHeatingSetpoint
         )
-        system_mode = self.get_matter_attribute_value(
-            clusters.Thermostat.Attributes.SystemMode
-        )
         boost_state = self.get_matter_attribute_value(
             clusters.WaterHeaterManagement.Attributes.BoostState
         )
-        if system_mode == clusters.Thermostat.Enums.SystemModeEnum.kOff:
-            self._attr_current_operation = STATE_OFF
-        elif boost_state == clusters.WaterHeaterManagement.Enums.BoostStateEnum.kActive:
+        if boost_state == clusters.WaterHeaterManagement.Enums.BoostStateEnum.kActive:
             self._attr_current_operation = STATE_HIGH_DEMAND
         else:
             self._attr_current_operation = STATE_ECO
@@ -223,7 +218,6 @@ DISCOVERY_SCHEMAS = [
             clusters.Thermostat.Attributes.AbsMinHeatSetpointLimit,
             clusters.Thermostat.Attributes.AbsMaxHeatSetpointLimit,
             clusters.Thermostat.Attributes.LocalTemperature,
-            clusters.Thermostat.Attributes.SystemMode,
             clusters.WaterHeaterManagement.Attributes.FeatureMap,
         ),
         optional_attributes=(

homeassistant/components/media_player/strings.json

@@ -260,7 +260,7 @@
     },
     "clear_playlist": {
       "description": "Removes all items from a media player's playlist.",
-      "name": "Clear media player playlist"
+      "name": "Clear playlist"
     },
     "join": {
       "description": "Groups media players together for synchronous playback. Only works on supported multiroom audio systems.",
@@ -270,44 +270,44 @@
           "name": "Group members"
         }
       },
-      "name": "Join media players"
+      "name": "Join"
     },
     "media_next_track": {
-      "description": "Selects the next track on a media player.",
-      "name": "Next track"
+      "description": "Selects the next track.",
+      "name": "Next"
     },
     "media_pause": {
       "description": "Pauses playback on a media player.",
-      "name": "Pause media"
+      "name": "[%key:common::action::pause%]"
     },
     "media_play": {
       "description": "Starts playback on a media player.",
-      "name": "Play media"
+      "name": "Play"
     },
     "media_play_pause": {
       "description": "Toggles play/pause on a media player.",
-      "name": "Play/Pause media"
+      "name": "Play/Pause"
     },
     "media_previous_track": {
-      "description": "Selects the previous track on a media player.",
-      "name": "Previous track"
+      "description": "Selects the previous track.",
+      "name": "Previous"
     },
     "media_seek": {
-      "description": "Allows you to go to a different part of the media that is currently playing on a media player.",
+      "description": "Allows you to go to a different part of the media that is currently playing.",
       "fields": {
         "seek_position": {
           "description": "Target position in the currently playing media. The format is platform dependent.",
           "name": "Position"
         }
       },
-      "name": "Seek media"
+      "name": "Seek"
     },
     "media_stop": {
       "description": "Stops playback on a media player.",
-      "name": "Stop media"
+      "name": "[%key:common::action::stop%]"
     },
     "play_media": {
-      "description": "Starts playing specified media on a media player.",
+      "description": "Starts playing specified media.",
       "fields": {
         "announce": {
           "description": "If the media should be played as an announcement.",
@@ -325,14 +325,14 @@
       "name": "Play media"
     },
     "repeat_set": {
-      "description": "Sets the repeat mode of a media player.",
+      "description": "Sets the repeat mode.",
       "fields": {
         "repeat": {
           "description": "Whether the media (one or all) should be played in a loop or not.",
           "name": "Repeat mode"
         }
       },
-      "name": "Set media player repeat"
+      "name": "Set repeat"
     },
     "search_media": {
       "description": "Searches the available media.",
@@ -357,14 +357,14 @@
       "name": "Search media"
     },
     "select_sound_mode": {
-      "description": "Selects a specific sound mode of a media player.",
+      "description": "Selects a specific sound mode.",
       "fields": {
         "sound_mode": {
           "description": "Name of the sound mode to switch to.",
           "name": "Sound mode"
         }
       },
-      "name": "Select media player sound mode"
+      "name": "Select sound mode"
     },
     "select_source": {
       "description": "Sends a media player the command to change the input source.",
@@ -374,37 +374,37 @@
           "name": "Source"
         }
       },
-      "name": "Select media player source"
+      "name": "Select source"
     },
     "shuffle_set": {
-      "description": "Enables or disables the shuffle mode of a media player.",
+      "description": "Enables or disables the shuffle mode.",
       "fields": {
         "shuffle": {
           "description": "Whether the media should be played in randomized order or not.",
           "name": "Shuffle mode"
         }
       },
-      "name": "Set media player shuffle"
+      "name": "Set shuffle"
     },
     "toggle": {
       "description": "Toggles a media player on/off.",
-      "name": "Toggle media player"
+      "name": "[%key:common::action::toggle%]"
     },
     "turn_off": {
       "description": "Turns off the power of a media player.",
-      "name": "Turn off media player"
+      "name": "[%key:common::action::turn_off%]"
     },
     "turn_on": {
       "description": "Turns on the power of a media player.",
-      "name": "Turn on media player"
+      "name": "[%key:common::action::turn_on%]"
     },
     "unjoin": {
       "description": "Removes a media player from a group. Only works on platforms which support player groups.",
-      "name": "Unjoin media player"
+      "name": "Unjoin"
     },
     "volume_down": {
       "description": "Turns down the volume of a media player.",
-      "name": "Turn down media player volume"
+      "name": "Turn down volume"
     },
     "volume_mute": {
       "description": "Mutes or unmutes a media player.",
@@ -414,7 +414,7 @@
           "name": "Muted"
         }
       },
-      "name": "Mute/unmute media player"
+      "name": "Mute/unmute volume"
     },
     "volume_set": {
       "description": "Sets the volume level of a media player.",
@@ -424,11 +424,11 @@
           "name": "Level"
         }
       },
-      "name": "Set media player volume"
+      "name": "Set volume"
     },
     "volume_up": {
       "description": "Turns up the volume of a media player.",
-      "name": "Turn up media player volume"
+      "name": "Turn up volume"
     }
   },
   "title": "Media player",

homeassistant/components/mutesync/__init__.py

@@ -2,26 +2,32 @@
 
 from __future__ import annotations
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
 
-from .coordinator import MutesyncConfigEntry, MutesyncUpdateCoordinator
+from .const import DOMAIN
+from .coordinator import MutesyncUpdateCoordinator
 
 PLATFORMS = [Platform.BINARY_SENSOR]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: MutesyncConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up mütesync from a config entry."""
-    coordinator = MutesyncUpdateCoordinator(hass, entry)
+    coordinator = hass.data.setdefault(DOMAIN, {})[entry.entry_id] = (
+        MutesyncUpdateCoordinator(hass, entry)
+    )
     await coordinator.async_config_entry_first_refresh()
 
-    entry.runtime_data = coordinator
-
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: MutesyncConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unload_ok:
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unload_ok

homeassistant/components/mutesync/binary_sensor.py

@@ -1,13 +1,14 @@
 """mütesync binary sensor entities."""
 
 from homeassistant.components.binary_sensor import BinarySensorEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import DOMAIN
-from .coordinator import MutesyncConfigEntry, MutesyncUpdateCoordinator
+from .coordinator import MutesyncUpdateCoordinator
 
 SENSORS = (
     "in_meeting",
@@ -17,11 +18,11 @@ SENSORS = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: MutesyncConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
-    """Set up the mütesync binary sensors."""
-    coordinator = config_entry.runtime_data
+    """Set up the mütesync button."""
+    coordinator = hass.data[DOMAIN][config_entry.entry_id]
     async_add_entities(
         [MuteStatus(coordinator, sensor_type) for sensor_type in SENSORS], True
     )

homeassistant/components/mutesync/coordinator.py

@@ -15,20 +15,18 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 
 from .const import DOMAIN, UPDATE_INTERVAL_IN_MEETING, UPDATE_INTERVAL_NOT_IN_MEETING
 
-type MutesyncConfigEntry = ConfigEntry[MutesyncUpdateCoordinator]
-
 _LOGGER = logging.getLogger(__name__)
 
 
 class MutesyncUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
     """Coordinator for the mütesync integration."""
 
-    config_entry: MutesyncConfigEntry
+    config_entry: ConfigEntry
 
     def __init__(
         self,
         hass: HomeAssistant,
-        entry: MutesyncConfigEntry,
+        entry: ConfigEntry,
     ) -> None:
         """Initialize the coordinator."""
         super().__init__(

homeassistant/components/netatmo/camera.py

@@ -34,7 +34,6 @@ from .const import (
     EVENT_TYPE_OFF,
     EVENT_TYPE_ON,
     MANUFACTURER,
-    NETATMO_ALIM_STATUS_ONLINE,
     NETATMO_CREATE_CAMERA,
     SERVICE_SET_CAMERA_LIGHT,
     SERVICE_SET_PERSON_AWAY,
@@ -175,16 +174,18 @@ class NetatmoCamera(NetatmoModuleEntity, Camera):
                 self._monitoring = False
             elif event_type in [EVENT_TYPE_CONNECTION, EVENT_TYPE_ON]:
                 _LOGGER.debug(
-                    "Camera %s has received %s event, turning on and enabling streaming if applicable",
+                    "Camera %s has received %s event, turning on and enabling streaming",
                     data["camera_id"],
                     event_type,
                 )
-                if self.device_type != "NDB":
-                    self._attr_is_streaming = True
+                self._attr_is_streaming = True
                 self._monitoring = True
             elif event_type == EVENT_TYPE_LIGHT_MODE:
                 if data.get("sub_type"):
                     self._light_state = data["sub_type"]
+                    self._attr_extra_state_attributes.update(
+                        {"light_state": self._light_state}
+                    )
                 else:
                     _LOGGER.debug(
                         "Camera %s has received light mode event without sub_type",
@@ -224,20 +225,6 @@ class NetatmoCamera(NetatmoModuleEntity, Camera):
             supported_features |= CameraEntityFeature.STREAM
         return supported_features
 
-    @property
-    def extra_state_attributes(self) -> dict[str, Any]:
-        """Return entity specific state attributes."""
-        return {
-            "id": self.device.entity_id,
-            "monitoring": self._monitoring,
-            "sd_status": self.device.sd_status,
-            "alim_status": self.device.alim_status,
-            "is_local": self.device.is_local,
-            "vpn_url": self.device.vpn_url,
-            "local_url": self.device.local_url,
-            "light_state": self._light_state,
-        }
-
     async def async_turn_off(self) -> None:
         """Turn off camera."""
         await self.device.async_monitoring_off()
@@ -261,10 +248,7 @@ class NetatmoCamera(NetatmoModuleEntity, Camera):
         self._attr_is_on = self.device.alim_status is not None
         self._attr_available = self.device.alim_status is not None
 
-        if self.device_type == "NDB":
-            self._monitoring = self.device.alim_status == NETATMO_ALIM_STATUS_ONLINE
-        elif self.device.monitoring is not None:
-            self._monitoring = self.device.monitoring
+        if self.device.monitoring is not None:
             self._attr_is_streaming = self.device.monitoring
             self._attr_motion_detection_enabled = self.device.monitoring
 
@@ -272,6 +256,19 @@ class NetatmoCamera(NetatmoModuleEntity, Camera):
             self.process_events(self.device.events)
         )
 
+        self._attr_extra_state_attributes.update(
+            {
+                "id": self.device.entity_id,
+                "monitoring": self._monitoring,
+                "sd_status": self.device.sd_status,
+                "alim_status": self.device.alim_status,
+                "is_local": self.device.is_local,
+                "vpn_url": self.device.vpn_url,
+                "local_url": self.device.local_url,
+                "light_state": self._light_state,
+            }
+        )
+
     def process_events(self, event_list: list[NaEvent]) -> dict:
         """Add meta data to events."""
         events = {}

homeassistant/components/netatmo/const.py

@@ -215,15 +215,5 @@ WEBHOOK_ACTIVATION = "webhook_activation"
 WEBHOOK_DEACTIVATION = "webhook_deactivation"
 WEBHOOK_NACAMERA_CONNECTION = "NACamera-connection"
 WEBHOOK_NOCAMERA_CONNECTION = "NOC-connection"
-WEBHOOK_NDB_CONNECTION = "NDB-connection"
 WEBHOOK_PUSH_TYPE = "push_type"
-CAMERA_CONNECTION_WEBHOOKS = [
-    WEBHOOK_NACAMERA_CONNECTION,
-    WEBHOOK_NOCAMERA_CONNECTION,
-    WEBHOOK_NDB_CONNECTION,
-]
-
-# Alimentation status (alim_status) for cameras and door bells (NDB).
-# For NDB there is no monitoring attribute in status but only alim_status.
-# 2 = Full power/online for NDB (and also Correct power adapter for NACamera).
-NETATMO_ALIM_STATUS_ONLINE = 2
+CAMERA_CONNECTION_WEBHOOKS = [WEBHOOK_NACAMERA_CONNECTION, WEBHOOK_NOCAMERA_CONNECTION]

homeassistant/components/nibe_heatpump/__init__.py

@@ -7,6 +7,7 @@ from nibe.connection.modbus import Modbus
 from nibe.connection.nibegw import NibeGW, ProductInfo
 from nibe.heatpump import HeatPump, Model
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     CONF_IP_ADDRESS,
     CONF_MODEL,
@@ -29,7 +30,7 @@ from .const import (
     CONF_WORD_SWAP,
     DOMAIN,
 )
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .coordinator import CoilCoordinator
 
 PLATFORMS: list[Platform] = [
     Platform.BINARY_SENSOR,
@@ -44,9 +45,7 @@ PLATFORMS: list[Platform] = [
 COIL_READ_RETRIES = 5
 
 
-async def async_setup_entry(
-    hass: HomeAssistant, entry: NibeHeatpumpConfigEntry
-) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Nibe Heat Pump from a config entry."""
 
     heatpump = HeatPump(Model[entry.data[CONF_MODEL]])
@@ -84,7 +83,8 @@ async def async_setup_entry(
 
     coordinator = CoilCoordinator(hass, entry, heatpump, connection)
 
-    entry.runtime_data = coordinator
+    data = hass.data.setdefault(DOMAIN, {})
+    data[entry.entry_id] = coordinator
 
     reg = dr.async_get(hass)
     device_entry = reg.async_get_or_create(
@@ -113,8 +113,9 @@ async def async_setup_entry(
     return True
 
 
-async def async_unload_entry(
-    hass: HomeAssistant, entry: NibeHeatpumpConfigEntry
-) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unload_ok := await hass.config_entries.async_unload_platforms(entry, PLATFORMS):
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unload_ok

homeassistant/components/nibe_heatpump/binary_sensor.py

@@ -5,22 +5,24 @@ from __future__ import annotations
 from nibe.coil import Coil, CoilData
 
 from homeassistant.components.binary_sensor import ENTITY_ID_FORMAT, BinarySensorEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .const import DOMAIN
+from .coordinator import CoilCoordinator
 from .entity import CoilEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: NibeHeatpumpConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up platform."""
 
-    coordinator = config_entry.runtime_data
+    coordinator: CoilCoordinator = hass.data[DOMAIN][config_entry.entry_id]
 
     async_add_entities(
         BinarySensor(coordinator, coil)

homeassistant/components/nibe_heatpump/button.py

@@ -6,23 +6,24 @@ from nibe.coil_groups import UNIT_COILGROUPS, UnitCoilGroup
 from nibe.exceptions import CoilNotFoundException
 
 from homeassistant.components.button import ButtonEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from .const import LOGGER
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .const import DOMAIN, LOGGER
+from .coordinator import CoilCoordinator
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: NibeHeatpumpConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up platform."""
 
-    coordinator = config_entry.runtime_data
+    coordinator: CoilCoordinator = hass.data[DOMAIN][config_entry.entry_id]
 
     def reset_buttons():
         if unit := UNIT_COILGROUPS.get(coordinator.series, {}).get("main"):

homeassistant/components/nibe_heatpump/climate.py

@@ -24,29 +24,31 @@ from homeassistant.components.climate import (
     HVACAction,
     HVACMode,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
+    DOMAIN,
     LOGGER,
     VALUES_COOL_WITH_ROOM_SENSOR_OFF,
     VALUES_MIXING_VALVE_CLOSED_STATE,
     VALUES_PRIORITY_COOLING,
     VALUES_PRIORITY_HEATING,
 )
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .coordinator import CoilCoordinator
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: NibeHeatpumpConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up platform."""
 
-    coordinator = config_entry.runtime_data
+    coordinator: CoilCoordinator = hass.data[DOMAIN][config_entry.entry_id]
 
     main_unit = UNIT_COILGROUPS[coordinator.series]["main"]
 

homeassistant/components/nibe_heatpump/coordinator.py

@@ -28,8 +28,6 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 
 from .const import DOMAIN, LOGGER
 
-type NibeHeatpumpConfigEntry = ConfigEntry[CoilCoordinator]
-
 
 class ContextCoordinator[_DataTypeT, _ContextTypeT](DataUpdateCoordinator[_DataTypeT]):
     """Update coordinator with context adjustments."""
@@ -75,12 +73,12 @@ class ContextCoordinator[_DataTypeT, _ContextTypeT](DataUpdateCoordinator[_DataT
 class CoilCoordinator(ContextCoordinator[dict[int, CoilData], int]):
     """Update coordinator for nibe heat pumps."""
 
-    config_entry: NibeHeatpumpConfigEntry
+    config_entry: ConfigEntry
 
     def __init__(
         self,
         hass: HomeAssistant,
-        config_entry: NibeHeatpumpConfigEntry,
+        config_entry: ConfigEntry,
         heatpump: HeatPump,
         connection: Connection,
     ) -> None:

homeassistant/components/nibe_heatpump/number.py

@@ -5,22 +5,24 @@ from __future__ import annotations
 from nibe.coil import Coil, CoilData
 
 from homeassistant.components.number import ENTITY_ID_FORMAT, NumberEntity, NumberMode
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .const import DOMAIN
+from .coordinator import CoilCoordinator
 from .entity import CoilEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: NibeHeatpumpConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up platform."""
 
-    coordinator = config_entry.runtime_data
+    coordinator: CoilCoordinator = hass.data[DOMAIN][config_entry.entry_id]
 
     async_add_entities(
         Number(coordinator, coil)

homeassistant/components/nibe_heatpump/select.py

@@ -5,22 +5,24 @@ from __future__ import annotations
 from nibe.coil import Coil, CoilData
 
 from homeassistant.components.select import ENTITY_ID_FORMAT, SelectEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .const import DOMAIN
+from .coordinator import CoilCoordinator
 from .entity import CoilEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: NibeHeatpumpConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up platform."""
 
-    coordinator = config_entry.runtime_data
+    coordinator: CoilCoordinator = hass.data[DOMAIN][config_entry.entry_id]
 
     async_add_entities(
         Select(coordinator, coil)

homeassistant/components/nibe_heatpump/sensor.py

@@ -11,6 +11,7 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     PERCENTAGE,
     EntityCategory,
@@ -27,7 +28,8 @@ from homeassistant.const import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .const import DOMAIN
+from .coordinator import CoilCoordinator
 from .entity import CoilEntity
 
 UNIT_DESCRIPTIONS = {
@@ -183,12 +185,12 @@ UNIT_DESCRIPTIONS = {
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: NibeHeatpumpConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up platform."""
 
-    coordinator = config_entry.runtime_data
+    coordinator: CoilCoordinator = hass.data[DOMAIN][config_entry.entry_id]
 
     async_add_entities(
         Sensor(coordinator, coil, UNIT_DESCRIPTIONS.get(coil.unit))

homeassistant/components/nibe_heatpump/switch.py

@@ -7,22 +7,24 @@ from typing import Any
 from nibe.coil import Coil, CoilData
 
 from homeassistant.components.switch import ENTITY_ID_FORMAT, SwitchEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import EntityCategory
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .const import DOMAIN
+from .coordinator import CoilCoordinator
 from .entity import CoilEntity
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: NibeHeatpumpConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up platform."""
 
-    coordinator = config_entry.runtime_data
+    coordinator: CoilCoordinator = hass.data[DOMAIN][config_entry.entry_id]
 
     async_add_entities(
         Switch(coordinator, coil)

homeassistant/components/nibe_heatpump/water_heater.py

@@ -14,27 +14,29 @@ from homeassistant.components.water_heater import (
     WaterHeaterEntity,
     WaterHeaterEntityFeature,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
+    DOMAIN,
     LOGGER,
     VALUES_TEMPORARY_LUX_INACTIVE,
     VALUES_TEMPORARY_LUX_ONE_TIME_INCREASE,
 )
-from .coordinator import CoilCoordinator, NibeHeatpumpConfigEntry
+from .coordinator import CoilCoordinator
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: NibeHeatpumpConfigEntry,
+    config_entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up platform."""
 
-    coordinator = config_entry.runtime_data
+    coordinator: CoilCoordinator = hass.data[DOMAIN][config_entry.entry_id]
 
     def water_heaters():
         for key, group in WATER_HEATER_COILGROUPS.get(coordinator.series, ()).items():

homeassistant/components/nina/__init__.py

@@ -18,7 +18,7 @@ from .const import (
 )
 from .coordinator import NinaConfigEntry, NINADataUpdateCoordinator
 
-PLATFORMS: list[Platform] = [Platform.BINARY_SENSOR, Platform.SENSOR]
+PLATFORMS: list[str] = [Platform.BINARY_SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: NinaConfigEntry) -> bool:

homeassistant/components/nina/binary_sensor.py

@@ -1,4 +1,4 @@
-"""NINA binary sensor platform."""
+"""NINA sensor platform."""
 
 from __future__ import annotations
 
@@ -88,19 +88,15 @@ class NINAMessage(NinaEntity, BinarySensorEntity):
         data = self._get_warning_data()
 
         return {
-            ATTR_HEADLINE: data.headline,  # Deprecated, remove in 2026.11
-            ATTR_DESCRIPTION: data.description,  # Deprecated, remove in 2026.11
-            ATTR_SENDER: data.sender,  # Deprecated, remove in 2026.11
-            ATTR_SEVERITY: data.severity or "Unknown",  # Deprecated, remove in 2026.11
-            ATTR_RECOMMENDED_ACTIONS: data.recommended_actions,  # Deprecated, remove in 2026.11
-            ATTR_AFFECTED_AREAS: data.affected_areas,  # Deprecated, remove in 2026.11
-            ATTR_WEB: data.more_info_url,  # Deprecated, remove in 2026.11
+            ATTR_HEADLINE: data.headline,
+            ATTR_DESCRIPTION: data.description,
+            ATTR_SENDER: data.sender,
+            ATTR_SEVERITY: data.severity,
+            ATTR_RECOMMENDED_ACTIONS: data.recommended_actions,
+            ATTR_AFFECTED_AREAS: data.affected_areas,
+            ATTR_WEB: data.web,
             ATTR_ID: data.id,
-            ATTR_SENT: data.sent.isoformat(),  # Deprecated, remove in 2026.11
-            ATTR_START: data.start.isoformat()
-            if data.start
-            else "",  # Deprecated, remove in 2026.11
-            ATTR_EXPIRES: data.expires.isoformat()
-            if data.expires
-            else "",  # Deprecated, remove in 2026.11
+            ATTR_SENT: data.sent,
+            ATTR_START: data.start,
+            ATTR_EXPIRES: data.expires,
         }

homeassistant/components/nina/config_flow.py

@@ -31,7 +31,6 @@ from .const import (
     CONST_REGIONS,
     DOMAIN,
     NO_MATCH_REGEX,
-    SENSOR_SUFFIXES,
 )
 
 
@@ -244,7 +243,32 @@ class OptionsFlowHandler(OptionsFlowWithReload):
                     user_input, self._all_region_codes_sorted
                 )
 
-                await self.remove_unused_entities(user_input)
+                entity_registry = er.async_get(self.hass)
+
+                entries = er.async_entries_for_config_entry(
+                    entity_registry, self.config_entry.entry_id
+                )
+
+                removed_entities_slots = [
+                    f"{region}-{slot_id}"
+                    for region in self.data[CONF_REGIONS]
+                    for slot_id in range(self.data[CONF_MESSAGE_SLOTS] + 1)
+                    if slot_id > user_input[CONF_MESSAGE_SLOTS]
+                ]
+
+                removed_entities_area = [
+                    f"{cfg_region}-{slot_id}"
+                    for slot_id in range(1, self.data[CONF_MESSAGE_SLOTS] + 1)
+                    for cfg_region in self.data[CONF_REGIONS]
+                    if cfg_region not in user_input[CONF_REGIONS]
+                ]
+
+                for entry in entries:
+                    for entity_uid in list(
+                        set(removed_entities_slots + removed_entities_area)
+                    ):
+                        if entry.unique_id == entity_uid:
+                            entity_registry.async_remove(entry.entity_id)
 
                 self.hass.config_entries.async_update_entry(
                     self.config_entry, data=user_input
@@ -263,35 +287,3 @@ class OptionsFlowHandler(OptionsFlowWithReload):
             data_schema=schema_with_suggested,
             errors=errors,
         )
-
-    async def remove_unused_entities(self, user_input: dict[str, Any]) -> None:
-        """Remove entities which are not used anymore."""
-        entity_registry = er.async_get(self.hass)
-
-        entries = er.async_entries_for_config_entry(
-            entity_registry, self.config_entry.entry_id
-        )
-
-        id_type_suffix = [f"-{sensor_id}" for sensor_id in SENSOR_SUFFIXES] + [""]
-
-        removed_entities_slots = [
-            f"{region}-{slot_id}{suffix}"
-            for region in self.data[CONF_REGIONS]
-            for slot_id in range(self.data[CONF_MESSAGE_SLOTS] + 1)
-            for suffix in id_type_suffix
-            if slot_id > user_input[CONF_MESSAGE_SLOTS]
-        ]
-
-        removed_entities_area = [
-            f"{cfg_region}-{slot_id}{suffix}"
-            for slot_id in range(1, self.data[CONF_MESSAGE_SLOTS] + 1)
-            for cfg_region in self.data[CONF_REGIONS]
-            for suffix in id_type_suffix
-            if cfg_region not in user_input[CONF_REGIONS]
-        ]
-
-        removed_uids = set(removed_entities_slots + removed_entities_area)
-
-        for entry in entries:
-            if entry.unique_id in removed_uids:
-                entity_registry.async_remove(entry.entity_id)

homeassistant/components/nina/const.py

@@ -15,8 +15,6 @@ DOMAIN: str = "nina"
 NO_MATCH_REGEX: str = "/(?!)/"
 ALL_MATCH_REGEX: str = ".*"
 
-SEVERITY_VALUES: list[str] = ["extreme", "severe", "moderate", "minor", "unknown"]
-
 CONF_REGIONS: str = "regions"
 CONF_MESSAGE_SLOTS: str = "slots"
 CONF_FILTERS: str = "filters"
@@ -36,17 +34,6 @@ ATTR_SENT: str = "sent"
 ATTR_START: str = "start"
 ATTR_EXPIRES: str = "expires"
 
-SENSOR_SUFFIXES: list[str] = [
-    "headline",
-    "sender",
-    "severity",
-    "affected_areas",
-    "more_info_url",
-    "sent",
-    "start",
-    "expires",
-]
-
 CONST_LIST_A_TO_D: list[str] = ["A", "Ä", "B", "C", "D"]
 CONST_LIST_E_TO_H: list[str] = ["E", "F", "G", "H"]
 CONST_LIST_I_TO_L: list[str] = ["I", "J", "K", "L"]