Bump holidays to 0.89

.claude/skills/integrations/SKILL.md

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

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

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

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

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

.devcontainer/devcontainer.json

@@ -8,6 +8,9 @@
     "PYTHONASYNCIODEBUG": "1"
   },
   "features": {
+    // Node feature required for Claude Code until fixed https://github.com/anthropics/devcontainer-features/issues/28
+    "ghcr.io/devcontainers/features/node:1": {},
+    "ghcr.io/anthropics/devcontainer-features/claude-code:1.0": {},
     "ghcr.io/devcontainers/features/github-cli:1": {}
   },
   // Port 5683 udp is used by Shelly integration

.github/PULL_REQUEST_TEMPLATE.md

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

.github/workflows/ci.yaml

@@ -479,22 +479,6 @@ jobs:
           . venv/bin/activate
           python -m script.gen_requirements_all validate
 
-  gen-copilot-instructions:
-    name: Check copilot instructions
-    runs-on: *runs-on-ubuntu
-    needs:
-      - info
-    if: |
-      github.event.inputs.pylint-only != 'true'
-      && github.event.inputs.mypy-only != 'true'
-      && github.event.inputs.audit-licenses-only != 'true'
-    steps:
-      - *checkout
-      - *setup-python-default
-      - name: Run gen_copilot_instructions.py
-        run: |
-          python -m script.gen_copilot_instructions validate
-
   dependency-review:
     name: Dependency review
     runs-on: *runs-on-ubuntu

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
+        uses: github/codeql-action/init@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@b20883b0cd1f46c72ae0ba6d1090936928f9fa30 # v4.32.0
+        uses: github/codeql-action/analyze@cdefb33c0f6224e58673d9004f47f7cb3e328b89 # v4.31.10
         with:
           category: "/language:python"

.strict-typing

@@ -53,7 +53,6 @@ homeassistant.components.air_quality.*
 homeassistant.components.airgradient.*
 homeassistant.components.airly.*
 homeassistant.components.airnow.*
-homeassistant.components.airobot.*
 homeassistant.components.airos.*
 homeassistant.components.airq.*
 homeassistant.components.airthings.*
@@ -376,7 +375,6 @@ homeassistant.components.no_ip.*
 homeassistant.components.nordpool.*
 homeassistant.components.notify.*
 homeassistant.components.notion.*
-homeassistant.components.nrgkick.*
 homeassistant.components.ntfy.*
 homeassistant.components.number.*
 homeassistant.components.nut.*

AGENTS.md

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

AGENTS.md

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

CLAUDE.md

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

CODEOWNERS

@@ -641,8 +641,6 @@ build.json @home-assistant/supervisor
 /tests/components/gpsd/ @fabaff @jrieger
 /homeassistant/components/gree/ @cmroche
 /tests/components/gree/ @cmroche
-/homeassistant/components/green_planet_energy/ @petschni
-/tests/components/green_planet_energy/ @petschni
 /homeassistant/components/greeneye_monitor/ @jkeljo
 /tests/components/greeneye_monitor/ @jkeljo
 /homeassistant/components/group/ @home-assistant/core
@@ -1126,8 +1124,6 @@ build.json @home-assistant/supervisor
 /tests/components/notify_events/ @matrozov @papajojo
 /homeassistant/components/notion/ @bachya
 /tests/components/notion/ @bachya
-/homeassistant/components/nrgkick/ @andijakl
-/tests/components/nrgkick/ @andijakl
 /homeassistant/components/nsw_fuel_station/ @nickw444
 /tests/components/nsw_fuel_station/ @nickw444
 /homeassistant/components/nsw_rural_fire_service_feed/ @exxamalte
@@ -1726,8 +1722,6 @@ build.json @home-assistant/supervisor
 /tests/components/twinkly/ @dr1rrb @Robbie1221 @Olen
 /homeassistant/components/twitch/ @joostlek
 /tests/components/twitch/ @joostlek
-/homeassistant/components/uhoo/ @getuhoo @joshsmonta
-/tests/components/uhoo/ @getuhoo @joshsmonta
 /homeassistant/components/ukraine_alarm/ @PaulAnnekov
 /tests/components/ukraine_alarm/ @PaulAnnekov
 /homeassistant/components/unifi/ @Kane610
@@ -1815,7 +1809,6 @@ build.json @home-assistant/supervisor
 /homeassistant/components/water_heater/ @home-assistant/core
 /tests/components/water_heater/ @home-assistant/core
 /homeassistant/components/waterfurnace/ @sdague @masterkoppa
-/tests/components/waterfurnace/ @sdague @masterkoppa
 /homeassistant/components/watergate/ @adam-the-hero
 /tests/components/watergate/ @adam-the-hero
 /homeassistant/components/watson_tts/ @rutkai

Dockerfile

@@ -24,7 +24,7 @@ ENV \
 COPY rootfs /
 
 # Add go2rtc binary
-COPY --from=ghcr.io/alexxit/go2rtc@sha256:675c318b23c06fd862a61d262240c9a63436b4050d177ffc68a32710d9e05bae /usr/local/bin/go2rtc /bin/go2rtc
+COPY --from=ghcr.io/alexxit/go2rtc@sha256:f394f6329f5389a4c9a7fc54b09fdec9621bbb78bf7a672b973440bbdfb02241 /usr/local/bin/go2rtc /bin/go2rtc
 
 RUN \
     # Verify go2rtc can be executed

homeassistant/bootstrap.py

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

homeassistant/brands/leviton.json

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

homeassistant/components/abode/__init__.py

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

homeassistant/components/abode/alarm_control_panel.py

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

homeassistant/components/abode/binary_sensor.py

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

homeassistant/components/abode/camera.py

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

homeassistant/components/abode/const.py

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

homeassistant/components/abode/cover.py

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

homeassistant/components/abode/entity.py

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

homeassistant/components/abode/light.py

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

homeassistant/components/abode/lock.py

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

homeassistant/components/abode/sensor.py

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

homeassistant/components/abode/services.py

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

homeassistant/components/abode/switch.py

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

homeassistant/components/adax/config_flow.py

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

homeassistant/components/adguard/config_flow.py

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

homeassistant/components/adguard/strings.json

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

homeassistant/components/airobot/climate.py

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

homeassistant/components/airobot/config_flow.py

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

homeassistant/components/airobot/coordinator.py

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

homeassistant/components/airobot/entity.py

@@ -35,6 +35,6 @@ class AirobotEntity(CoordinatorEntity[AirobotDataUpdateCoordinator]):
             manufacturer="Airobot",
             model="Thermostat",
             model_id="TE1",
-            sw_version=status.fw_version_string,
-            hw_version=status.hw_version_string,
+            sw_version=str(status.fw_version),
+            hw_version=str(status.hw_version),
         )

homeassistant/components/airobot/manifest.json

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

homeassistant/components/airobot/quality_scale.yaml

@@ -69,4 +69,4 @@ rules:
   # Platinum
   async-dependency: done
   inject-websession: done
-  strict-typing: done
+  strict-typing: todo

homeassistant/components/airobot/sensor.py

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

homeassistant/components/airos/manifest.json

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

homeassistant/components/airq/icons.json

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

homeassistant/components/airq/sensor.py

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

homeassistant/components/airq/strings.json

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

homeassistant/components/airthings_ble/icons.json

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

homeassistant/components/airthings_ble/sensor.py

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

homeassistant/components/airthings_ble/strings.json

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

homeassistant/components/aladdin_connect/strings.json

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

homeassistant/components/anthropic/config_flow.py

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

homeassistant/components/august/strings.json

@@ -9,7 +9,6 @@
       "no_url_available": "[%key:common::config_flow::abort::oauth2_no_url_available%]",
       "oauth_error": "[%key:common::config_flow::abort::oauth2_error%]",
       "oauth_failed": "[%key:common::config_flow::abort::oauth2_failed%]",
-      "oauth_implementation_unavailable": "[%key:common::config_flow::abort::oauth2_implementation_unavailable%]",
       "oauth_timeout": "[%key:common::config_flow::abort::oauth2_timeout%]",
       "oauth_unauthorized": "[%key:common::config_flow::abort::oauth2_unauthorized%]",
       "reauth_invalid_user": "Reauthenticate must use the same account.",

homeassistant/components/automation/__init__.py

@@ -125,18 +125,10 @@ NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG = "new_triggers_conditions"
 _EXPERIMENTAL_CONDITION_PLATFORMS = {
     "alarm_control_panel",
     "assist_satellite",
-    "climate",
     "device_tracker",
     "fan",
-    "humidifier",
-    "lawn_mower",
     "light",
-    "lock",
-    "media_player",
-    "person",
     "siren",
-    "switch",
-    "vacuum",
 }
 
 _EXPERIMENTAL_TRIGGER_PLATFORMS = {

homeassistant/components/bluetooth/manifest.json

@@ -15,7 +15,7 @@
   ],
   "quality_scale": "internal",
   "requirements": [
-    "bleak==2.1.1",
+    "bleak==2.0.0",
     "bleak-retry-connector==4.4.3",
     "bluetooth-adapters==2.1.0",
     "bluetooth-auto-recovery==1.5.3",

homeassistant/components/calendar/__init__.py

@@ -32,7 +32,7 @@ from homeassistant.core import (
     callback,
 )
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import config_validation as cv, entity_registry as er
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity import Entity, EntityDescription
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.event import async_track_point_in_time
@@ -516,26 +516,6 @@ class CalendarEntity(Entity):
 
     _alarm_unsubs: list[CALLBACK_TYPE] | None = None
 
-    _attr_initial_color: str | None = None
-
-    @property
-    def initial_color(self) -> str | None:
-        """Return the initial color for the calendar entity."""
-        return self._attr_initial_color
-
-    def get_initial_entity_options(self) -> er.EntityOptionsType | None:
-        """Return initial entity options."""
-        if self.initial_color is None:
-            return None
-
-        # Validate that it's a valid hex color string with # prefix
-        try:
-            validated_color = cv.color_hex(self.initial_color)
-        except vol.Invalid:
-            return None
-
-        return {DOMAIN: {"color": validated_color}}
-
     @property
     def event(self) -> CalendarEvent | None:
         """Return the next upcoming event."""
@@ -553,8 +533,8 @@ class CalendarEntity(Entity):
             "all_day": event.all_day,
             "start_time": event.start_datetime_local.strftime(DATE_STR_FORMAT),
             "end_time": event.end_datetime_local.strftime(DATE_STR_FORMAT),
-            "location": event.location or "",
-            "description": event.description or "",
+            "location": event.location if event.location else "",
+            "description": event.description if event.description else "",
         }
 
     @final

homeassistant/components/camera/__init__.py

@@ -234,7 +234,7 @@ async def _async_get_stream_image(
     height: int | None = None,
     wait_for_next_keyframe: bool = False,
 ) -> bytes | None:
-    if (provider := camera.webrtc_provider) and (
+    if (provider := camera._webrtc_provider) and (  # noqa: SLF001
         image := await provider.async_get_image(camera, width=width, height=height)
     ) is not None:
         return image
@@ -515,12 +515,6 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
             return False
         return super().available
 
-    @final
-    @property
-    def webrtc_provider(self) -> CameraWebRTCProvider | None:
-        """Return the WebRTC provider."""
-        return self._webrtc_provider
-
     async def async_create_stream(self) -> Stream | None:
         """Create a Stream for stream_source."""
         # There is at most one stream (a decode worker) per camera
@@ -680,13 +674,6 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
         self.__supports_stream = self.supported_features & CameraEntityFeature.STREAM
         await self.async_refresh_providers(write_state=False)
 
-    async def async_internal_will_remove_from_hass(self) -> None:
-        """Run when entity will be removed from hass."""
-        if self._webrtc_provider:
-            await self._webrtc_provider.async_unregister_camera(self)
-            self._webrtc_provider = None
-        await super().async_internal_will_remove_from_hass()
-
     async def async_refresh_providers(self, *, write_state: bool = True) -> None:
         """Determine if any of the registered providers are suitable for this entity.
 
@@ -703,19 +690,11 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
                 async_get_supported_provider
             )
 
-        if old_provider == new_provider:
-            return
-
-        if old_provider:
-            await old_provider.async_unregister_camera(self)
-
-        if new_provider:
-            await new_provider.async_register_camera(self)
-
-        self._webrtc_provider = new_provider
-        self._invalidate_camera_capabilities_cache()
-        if write_state:
-            self.async_write_ha_state()
+        if old_provider != new_provider:
+            self._webrtc_provider = new_provider
+            self._invalidate_camera_capabilities_cache()
+            if write_state:
+                self.async_write_ha_state()
 
     async def _async_get_supported_webrtc_provider[_T](
         self, fn: Callable[[HomeAssistant, Camera], Coroutine[None, None, _T | None]]
@@ -968,10 +947,6 @@ async def websocket_update_prefs(
         _LOGGER.error("Error setting camera preferences: %s", ex)
         connection.send_error(msg["id"], "update_failed", str(ex))
     else:
-        if (camera := hass.data[DATA_COMPONENT].get_entity(entity_id)) and (
-            provider := camera.webrtc_provider
-        ):
-            await provider.async_on_camera_prefs_update(camera)
         connection.send_result(msg["id"], entity_prefs)
 
 

homeassistant/components/camera/webrtc.py

@@ -146,7 +146,7 @@ class CameraWebRTCProvider(ABC):
     @callback
     def async_close_session(self, session_id: str) -> None:
         """Close the session."""
-        ## This is an optional method so we need a default here.
+        return  ## This is an optional method so we need a default here.
 
     async def async_get_image(
         self,
@@ -157,27 +157,6 @@ class CameraWebRTCProvider(ABC):
         """Get an image from the camera."""
         return None
 
-    async def async_register_camera(
-        self,
-        camera: Camera,
-    ) -> None:
-        """Will be called when the provider is registered for a camera."""
-        ## This is an optional method so we need a default here.
-
-    async def async_unregister_camera(
-        self,
-        camera: Camera,
-    ) -> None:
-        """Will be called when the provider is unregistered for a camera."""
-        ## This is an optional method so we need a default here.
-
-    async def async_on_camera_prefs_update(
-        self,
-        camera: Camera,
-    ) -> None:
-        """Will be called when the camera preferences are updated."""
-        ## This is an optional method so we need a default here.
-
 
 @callback
 def async_register_webrtc_provider(

homeassistant/components/climate/condition.py

@@ -1,39 +0,0 @@
-"""Provides conditions for climates."""
-
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.condition import (
-    Condition,
-    make_entity_state_attribute_condition,
-    make_entity_state_condition,
-)
-
-from .const import ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
-
-CONDITIONS: dict[str, type[Condition]] = {
-    "is_off": make_entity_state_condition(DOMAIN, HVACMode.OFF),
-    "is_on": make_entity_state_condition(
-        DOMAIN,
-        {
-            HVACMode.AUTO,
-            HVACMode.COOL,
-            HVACMode.DRY,
-            HVACMode.FAN_ONLY,
-            HVACMode.HEAT,
-            HVACMode.HEAT_COOL,
-        },
-    ),
-    "is_cooling": make_entity_state_attribute_condition(
-        DOMAIN, ATTR_HVAC_ACTION, HVACAction.COOLING
-    ),
-    "is_drying": make_entity_state_attribute_condition(
-        DOMAIN, ATTR_HVAC_ACTION, HVACAction.DRYING
-    ),
-    "is_heating": make_entity_state_attribute_condition(
-        DOMAIN, ATTR_HVAC_ACTION, HVACAction.HEATING
-    ),
-}
-
-
-async def async_get_conditions(hass: HomeAssistant) -> dict[str, type[Condition]]:
-    """Return the climate conditions."""
-    return CONDITIONS

homeassistant/components/climate/conditions.yaml

@@ -1,20 +0,0 @@
-.condition_common: &condition_common
-  target:
-    entity:
-      domain: climate
-  fields:
-    behavior:
-      required: true
-      default: any
-      selector:
-        select:
-          translation_key: condition_behavior
-          options:
-            - all
-            - any
-
-is_off: *condition_common
-is_on: *condition_common
-is_cooling: *condition_common
-is_drying: *condition_common
-is_heating: *condition_common

homeassistant/components/climate/icons.json

@@ -1,21 +1,4 @@
 {
-  "conditions": {
-    "is_cooling": {
-      "condition": "mdi:snowflake"
-    },
-    "is_drying": {
-      "condition": "mdi:water-percent"
-    },
-    "is_heating": {
-      "condition": "mdi:fire"
-    },
-    "is_off": {
-      "condition": "mdi:power-off"
-    },
-    "is_on": {
-      "condition": "mdi:power-on"
-    }
-  },
   "entity_component": {
     "_": {
       "default": "mdi:thermostat",

homeassistant/components/climate/strings.json

@@ -1,62 +1,8 @@
 {
   "common": {
-    "condition_behavior_description": "How the state should match on the targeted climate-control devices.",
-    "condition_behavior_name": "Behavior",
     "trigger_behavior_description": "The behavior of the targeted climates to trigger on.",
     "trigger_behavior_name": "Behavior"
   },
-  "conditions": {
-    "is_cooling": {
-      "description": "Tests if one or more climate-control devices are cooling.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::condition_behavior_description%]",
-          "name": "[%key:component::climate::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Climate-control device is cooling"
-    },
-    "is_drying": {
-      "description": "Tests if one or more climate-control devices are drying.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::condition_behavior_description%]",
-          "name": "[%key:component::climate::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Climate-control device is drying"
-    },
-    "is_heating": {
-      "description": "Tests if one or more climate-control devices are heating.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::condition_behavior_description%]",
-          "name": "[%key:component::climate::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Climate-control device is heating"
-    },
-    "is_off": {
-      "description": "Tests if one or more climate-control devices are off.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::condition_behavior_description%]",
-          "name": "[%key:component::climate::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Climate-control device is off"
-    },
-    "is_on": {
-      "description": "Tests if one or more climate-control devices are on.",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::climate::common::condition_behavior_description%]",
-          "name": "[%key:component::climate::common::condition_behavior_name%]"
-        }
-      },
-      "name": "Climate-control device is on"
-    }
-  },
   "device_automation": {
     "action_type": {
       "set_hvac_mode": "Change HVAC mode on {entity_name}",
@@ -235,12 +181,6 @@
     }
   },
   "selector": {
-    "condition_behavior": {
-      "options": {
-        "all": "All",
-        "any": "Any"
-      }
-    },
     "hvac_mode": {
       "options": {
         "auto": "[%key:common::state::auto%]",

homeassistant/components/cloud/http_api.py

@@ -42,7 +42,6 @@ from homeassistant.loader import (
     async_get_loaded_integration,
 )
 from homeassistant.util.location import async_detect_location_info
-from homeassistant.util.package import async_get_installed_packages
 
 from .alexa_config import entity_supported as entity_supported_by_alexa
 from .assist_pipeline import async_create_cloud_pipeline
@@ -572,25 +571,6 @@ class DownloadSupportPackageView(HomeAssistantView):
                 "</details>\n\n"
             )
 
-        # Add installed packages section
-        try:
-            installed_packages = await async_get_installed_packages()
-        except Exception:  # noqa: BLE001
-            # Broad exception catch for robustness in support package generation
-            markdown += "## Installed packages\n\n"
-            markdown += "Unable to collect installed packages information\n\n"
-        else:
-            if installed_packages:
-                markdown += "## Installed packages\n\n"
-                markdown += (
-                    "<details><summary>Installed packages</summary>\n\n"
-                    "Package | Version\n"
-                    "--- | ---\n"
-                )
-                for pkg in sorted(installed_packages, key=lambda p: p["name"].lower()):
-                    markdown += f"{pkg['name']} | {pkg['version']}\n"
-                markdown += "\n</details>\n\n"
-
         log_handler = hass.data[DATA_CLOUD_LOG_HANDLER]
         logs = "\n".join(await log_handler.get_logs(hass))
         markdown += (

homeassistant/components/compit/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["compit"],
   "quality_scale": "bronze",
-  "requirements": ["compit-inext-api==0.6.0"]
+  "requirements": ["compit-inext-api==0.4.2"]
 }

homeassistant/components/control4/config_flow.py

@@ -3,12 +3,12 @@
 from __future__ import annotations
 
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from aiohttp.client_exceptions import ClientError
 from pyControl4.account import C4Account
 from pyControl4.director import C4Director
-from pyControl4.error_handling import BadCredentials, NotFound, Unauthorized
+from pyControl4.error_handling import NotFound, Unauthorized
 import voluptuous as vol
 
 from homeassistant.config_entries import (
@@ -22,7 +22,8 @@ from homeassistant.const import (
     CONF_SCAN_INTERVAL,
     CONF_USERNAME,
 )
-from homeassistant.core import callback
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import aiohttp_client, config_validation as cv
 from homeassistant.helpers.device_registry import format_mac
 
@@ -45,107 +46,106 @@ DATA_SCHEMA = vol.Schema(
 )
 
 
+class Control4Validator:
+    """Validates that config details can be used to authenticate and communicate with Control4."""
+
+    def __init__(
+        self, host: str, username: str, password: str, hass: HomeAssistant
+    ) -> None:
+        """Initialize."""
+        self.host = host
+        self.username = username
+        self.password = password
+        self.controller_unique_id = None
+        self.director_bearer_token = None
+        self.hass = hass
+
+    async def authenticate(self) -> bool:
+        """Test if we can authenticate with the Control4 account API."""
+        try:
+            account_session = aiohttp_client.async_get_clientsession(self.hass)
+            account = C4Account(self.username, self.password, account_session)
+            # Authenticate with Control4 account
+            await account.getAccountBearerToken()
+
+            # Get controller name
+            account_controllers = await account.getAccountControllers()
+            self.controller_unique_id = account_controllers["controllerCommonName"]
+
+            # Get bearer token to communicate with controller locally
+            self.director_bearer_token = (
+                await account.getDirectorBearerToken(self.controller_unique_id)
+            )["token"]
+        except (Unauthorized, NotFound):
+            return False
+        return True
+
+    async def connect_to_director(self) -> bool:
+        """Test if we can connect to the local Control4 Director."""
+        try:
+            director_session = aiohttp_client.async_get_clientsession(
+                self.hass, verify_ssl=False
+            )
+            director = C4Director(
+                self.host, self.director_bearer_token, director_session
+            )
+            await director.getAllItemInfo()
+        except (Unauthorized, ClientError, TimeoutError):
+            _LOGGER.error("Failed to connect to the Control4 controller")
+            return False
+        return True
+
+
 class Control4ConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Control4."""
 
     VERSION = 1
 
-    async def _async_try_connect(
-        self, user_input: dict[str, Any]
-    ) -> tuple[dict[str, str], dict[str, Any] | None, dict[str, str]]:
-        """Try to connect to Control4 and return errors, data, and placeholders."""
-        errors: dict[str, str] = {}
-        description_placeholders: dict[str, str] = {}
-        data: dict[str, Any] | None = None
-
-        host = user_input[CONF_HOST]
-        username = user_input[CONF_USERNAME]
-        password = user_input[CONF_PASSWORD]
-
-        # Step 1: Authenticate with Control4 cloud API
-        account_session = aiohttp_client.async_get_clientsession(self.hass)
-        account = C4Account(username, password, account_session)
-        try:
-            await account.getAccountBearerToken()
-
-            account_controllers = await account.getAccountControllers()
-            controller_unique_id = account_controllers["controllerCommonName"]
-
-            director_bearer_token = (
-                await account.getDirectorBearerToken(controller_unique_id)
-            )["token"]
-        except (BadCredentials, Unauthorized):
-            errors["base"] = "invalid_auth"
-            return errors, data, description_placeholders
-        except NotFound:
-            errors["base"] = "controller_not_found"
-            return errors, data, description_placeholders
-        except Exception:
-            _LOGGER.exception(
-                "Unexpected exception during Control4 account authentication"
-            )
-            errors["base"] = "unknown"
-            return errors, data, description_placeholders
-
-        # Step 2: Connect to local Control4 Director
-        director_session = aiohttp_client.async_get_clientsession(
-            self.hass, verify_ssl=False
-        )
-        director = C4Director(host, director_bearer_token, director_session)
-        try:
-            await director.getAllItemInfo()
-        except Unauthorized:
-            errors["base"] = "director_auth_failed"
-            return errors, data, description_placeholders
-        except (ClientError, TimeoutError):
-            errors["base"] = "cannot_connect"
-            description_placeholders["host"] = host
-            return errors, data, description_placeholders
-        except Exception:
-            _LOGGER.exception(
-                "Unexpected exception during Control4 director connection"
-            )
-            errors["base"] = "unknown"
-            return errors, data, description_placeholders
-
-        # Success - return the data needed for entry creation
-        data = {
-            CONF_HOST: host,
-            CONF_USERNAME: username,
-            CONF_PASSWORD: password,
-            CONF_CONTROLLER_UNIQUE_ID: controller_unique_id,
-        }
-
-        return errors, data, description_placeholders
-
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle the initial step."""
-        errors: dict[str, str] = {}
-        description_placeholders: dict[str, str] = {}
-
+        errors = {}
         if user_input is not None:
-            errors, data, description_placeholders = await self._async_try_connect(
-                user_input
+            hub = Control4Validator(
+                user_input[CONF_HOST],
+                user_input[CONF_USERNAME],
+                user_input[CONF_PASSWORD],
+                self.hass,
             )
+            try:
+                if not await hub.authenticate():
+                    raise InvalidAuth  # noqa: TRY301
+                if not await hub.connect_to_director():
+                    raise CannotConnect  # noqa: TRY301
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
 
-            if not errors and data is not None:
-                controller_unique_id = data[CONF_CONTROLLER_UNIQUE_ID]
+            if not errors:
+                controller_unique_id = hub.controller_unique_id
+                if TYPE_CHECKING:
+                    assert hub.controller_unique_id
                 mac = (controller_unique_id.split("_", 3))[2]
                 formatted_mac = format_mac(mac)
                 await self.async_set_unique_id(formatted_mac)
                 self._abort_if_unique_id_configured()
                 return self.async_create_entry(
                     title=controller_unique_id,
-                    data=data,
+                    data={
+                        CONF_HOST: user_input[CONF_HOST],
+                        CONF_USERNAME: user_input[CONF_USERNAME],
+                        CONF_PASSWORD: user_input[CONF_PASSWORD],
+                        CONF_CONTROLLER_UNIQUE_ID: controller_unique_id,
+                    },
                 )
 
         return self.async_show_form(
-            step_id="user",
-            data_schema=DATA_SCHEMA,
-            errors=errors,
-            description_placeholders=description_placeholders,
+            step_id="user", data_schema=DATA_SCHEMA, errors=errors
         )
 
     @staticmethod
@@ -178,3 +178,11 @@ class OptionsFlowHandler(OptionsFlowWithReload):
             }
         )
         return self.async_show_form(step_id="init", data_schema=data_schema)
+
+
+class CannotConnect(HomeAssistantError):
+    """Error to indicate we cannot connect."""
+
+
+class InvalidAuth(HomeAssistantError):
+    """Error to indicate there is invalid auth."""

homeassistant/components/control4/media_player.py

@@ -221,7 +221,7 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
             | MediaPlayerEntityFeature.SELECT_SOURCE
         )
 
-    def _create_api_object(self) -> C4Room:
+    def _create_api_object(self):
         """Create a pyControl4 device object.
 
         This exists so the director token used is always the latest one, without needing to re-init the entire entity.
@@ -254,7 +254,7 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
             return media_info["mediainfo"]
         return None
 
-    def _get_current_source_state(self) -> MediaPlayerState | None:
+    def _get_current_source_state(self) -> str | None:
         current_source = self._get_current_playing_device_id()
         while current_source:
             current_data = self.coordinator.data.get(current_source, None)
@@ -277,7 +277,7 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
         return MediaPlayerDeviceClass.SPEAKER
 
     @property
-    def state(self) -> MediaPlayerState:
+    def state(self):
         """Return whether this room is on or idle."""
 
         if source_state := self._get_current_source_state():
@@ -289,7 +289,7 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
         return MediaPlayerState.IDLE
 
     @property
-    def source(self) -> str | None:
+    def source(self):
         """Get the current source."""
         current_source = self._get_current_playing_device_id()
         if not current_source or current_source not in self._sources:
@@ -310,7 +310,7 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
         return self._sources[current_source].name
 
     @property
-    def media_content_type(self) -> MediaType | None:
+    def media_content_type(self):
         """Get current content type if available."""
         current_source = self._get_current_playing_device_id()
         if not current_source:
@@ -319,7 +319,7 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
             return MediaType.VIDEO
         return MediaType.MUSIC
 
-    async def async_media_play_pause(self) -> None:
+    async def async_media_play_pause(self):
         """If possible, toggle the current play/pause state.
 
         Not every source supports play/pause.
@@ -335,16 +335,16 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
         return [x.name for x in self._sources.values()]
 
     @property
-    def volume_level(self) -> float:
+    def volume_level(self):
         """Get the volume level."""
         return self.coordinator.data[self._idx][CONTROL4_VOLUME_STATE] / 100
 
     @property
-    def is_volume_muted(self) -> bool:
+    def is_volume_muted(self):
         """Check if the volume is muted."""
         return bool(self.coordinator.data[self._idx][CONTROL4_MUTED_STATE])
 
-    async def async_select_source(self, source: str) -> None:
+    async def async_select_source(self, source):
         """Select a new source."""
         for avail_source in self._sources.values():
             if avail_source.name == source:
@@ -359,12 +359,12 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
 
         await self.coordinator.async_request_refresh()
 
-    async def async_turn_off(self) -> None:
+    async def async_turn_off(self):
         """Turn off the room."""
         await self._create_api_object().setRoomOff()
         await self.coordinator.async_request_refresh()
 
-    async def async_mute_volume(self, mute: bool) -> None:
+    async def async_mute_volume(self, mute):
         """Mute the room."""
         if mute:
             await self._create_api_object().setMuteOn()
@@ -372,32 +372,32 @@ class Control4Room(Control4Entity, MediaPlayerEntity):
             await self._create_api_object().setMuteOff()
         await self.coordinator.async_request_refresh()
 
-    async def async_set_volume_level(self, volume: float) -> None:
+    async def async_set_volume_level(self, volume):
         """Set room volume, 0-1 scale."""
         await self._create_api_object().setVolume(int(volume * 100))
         await self.coordinator.async_request_refresh()
 
-    async def async_volume_up(self) -> None:
+    async def async_volume_up(self):
         """Increase the volume by 1."""
         await self._create_api_object().setIncrementVolume()
         await self.coordinator.async_request_refresh()
 
-    async def async_volume_down(self) -> None:
+    async def async_volume_down(self):
         """Decrease the volume by 1."""
         await self._create_api_object().setDecrementVolume()
         await self.coordinator.async_request_refresh()
 
-    async def async_media_pause(self) -> None:
+    async def async_media_pause(self):
         """Issue a pause command."""
         await self._create_api_object().setPause()
         await self.coordinator.async_request_refresh()
 
-    async def async_media_play(self) -> None:
+    async def async_media_play(self):
         """Issue a play command."""
         await self._create_api_object().setPlay()
         await self.coordinator.async_request_refresh()
 
-    async def async_media_stop(self) -> None:
+    async def async_media_stop(self):
         """Issue a stop command."""
         await self._create_api_object().setStop()
         await self.coordinator.async_request_refresh()

homeassistant/components/control4/strings.json

@@ -4,9 +4,7 @@
       "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
     },
     "error": {
-      "cannot_connect": "Failed to connect to the Control4 director at {host}",
-      "controller_not_found": "No Control4 controller found on this account",
-      "director_auth_failed": "The Control4 director rejected the authentication token",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
       "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
       "unknown": "[%key:common::config_flow::error::unknown%]"
     },

homeassistant/components/coolmaster/climate.py

@@ -124,9 +124,7 @@ class CoolmasterClimate(CoolmasterEntity, ClimateEntity):
     @property
     def fan_mode(self):
         """Return the fan setting."""
-
-        # Normalize to lowercase for lookup, and pass unknown values through.
-        return CM_TO_HA_FAN.get(self._unit.fan_speed.lower(), self._unit.fan_speed)
+        return CM_TO_HA_FAN[self._unit.fan_speed]
 
     @property
     def fan_modes(self):

homeassistant/components/deconz/entity.py

@@ -154,7 +154,7 @@ class DeconzSceneMixin(DeconzDevice[PydeconzScene]):
         """Set up a scene."""
         super().__init__(device, hub)
 
-        self.deconz_group = self.hub.api.groups[device.group_id]
+        self.group = self.hub.api.groups[device.group_id]
 
         self._attr_name = device.name
         self._group_identifier = self.get_parent_identifier()
@@ -165,7 +165,7 @@ class DeconzSceneMixin(DeconzDevice[PydeconzScene]):
 
     def get_parent_identifier(self) -> str:
         """Describe a unique identifier for group this scene belongs to."""
-        return f"{self.hub.bridgeid}-{self.deconz_group.deconz_id}"
+        return f"{self.hub.bridgeid}-{self.group.deconz_id}"
 
     @property
     def unique_id(self) -> str:
@@ -179,6 +179,6 @@ class DeconzSceneMixin(DeconzDevice[PydeconzScene]):
             identifiers={(DOMAIN, self._group_identifier)},
             manufacturer="dresden elektronik",
             model="deCONZ group",
-            name=self.deconz_group.name,
+            name=self.group.name,
             via_device=(DOMAIN, self.hub.api.config.bridge_id),
         )

homeassistant/components/deconz/strings.json

@@ -14,8 +14,8 @@
     "flow_title": "{host}",
     "step": {
       "hassio_confirm": {
-        "description": "Do you want to configure Home Assistant to connect to the deCONZ gateway provided by the app {addon}?",
-        "title": "deCONZ Zigbee gateway via Home Assistant app"
+        "description": "Do you want to configure Home Assistant to connect to the deCONZ gateway provided by the add-on {addon}?",
+        "title": "deCONZ Zigbee gateway via Home Assistant add-on"
       },
       "link": {
         "description": "Unlock your deCONZ gateway to register with Home Assistant.\n\n1. Go to deCONZ Settings > Gateway > Advanced\n2. Select the **Authenticate app** button",

homeassistant/components/diagnostics/__init__.py

@@ -74,7 +74,7 @@ class DiagnosticsData:
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
-    """Set up Diagnostics integration."""
+    """Set up Diagnostics from a config entry."""
     hass.data[_DIAGNOSTICS_DATA] = DiagnosticsData()
 
     await integration_platform.async_process_integration_platforms(

homeassistant/components/duckdns/manifest.json

@@ -5,6 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/duckdns",
   "integration_type": "service",
-  "iot_class": "cloud_polling",
-  "quality_scale": "platinum"
+  "iot_class": "cloud_polling"
 }

homeassistant/components/duckdns/quality_scale.yaml

@@ -1,102 +0,0 @@
-rules:
-  # Bronze
-  action-setup: done
-  appropriate-polling: done
-  brands: done
-  common-modules: done
-  config-flow-test-coverage: done
-  config-flow: done
-  dependency-transparency:
-    status: exempt
-    comment: no external dependencies
-  docs-actions: done
-  docs-high-level-description: done
-  docs-installation-instructions: done
-  docs-removal-instructions: done
-  entity-event-setup:
-    status: exempt
-    comment: integration has no entities
-  entity-unique-id:
-    status: exempt
-    comment: integration has no entities
-  has-entity-name:
-    status: exempt
-    comment: integration has no entities
-  runtime-data: done
-  test-before-configure: done
-  test-before-setup: done
-  unique-config-entry: done
-
-  # Silver
-  action-exceptions: done
-  config-entry-unloading: done
-  docs-configuration-parameters:
-    status: exempt
-    comment: the integration has no options
-  docs-installation-parameters: done
-  entity-unavailable:
-    status: exempt
-    comment: integration has no entities
-  integration-owner: done
-  log-when-unavailable: done
-  parallel-updates:
-    status: exempt
-    comment: integration has no entity platforms
-  reauthentication-flow:
-    status: exempt
-    comment: service does not explicitly return authentication errors
-  test-coverage: done
-
-  # Gold
-  devices:
-    status: exempt
-    comment: integration has no devices
-  diagnostics:
-    status: exempt
-    comment: the integration has no runtime data and entry data only contains sensitive information
-  discovery-update-info:
-    status: exempt
-    comment: the service cannot be discovered
-  discovery:
-    status: exempt
-    comment: the service cannot be discovered
-  docs-data-update: done
-  docs-examples: done
-  docs-known-limitations: done
-  docs-supported-devices:
-    status: exempt
-    comment: the integration is a service
-  docs-supported-functions:
-    status: exempt
-    comment: integration has no entities or actions
-  docs-troubleshooting: done
-  docs-use-cases: done
-  dynamic-devices:
-    status: exempt
-    comment: integration has no devices
-  entity-category:
-    status: exempt
-    comment: integration has no entities
-  entity-device-class:
-    status: exempt
-    comment: integration has no entities
-  entity-disabled-by-default:
-    status: exempt
-    comment: integration has no entities
-  entity-translations:
-    status: exempt
-    comment: integration has no entities
-  exception-translations: done
-  icon-translations: done
-  reconfiguration-flow: done
-  repair-issues: done
-  stale-devices:
-    status: exempt
-    comment: integration has no devices
-
-  # Platinum
-  async-dependency:
-    status: exempt
-    comment: integration has no external dependencies
-  inject-websession: done
-  strict-typing: done

homeassistant/components/dynalite/panel.py

@@ -110,7 +110,7 @@ async def async_register_dynalite_frontend(hass: HomeAssistant):
         frontend_url_path=DOMAIN,
         config_panel_domain=DOMAIN,
         webcomponent_name="dynalite-panel",
-        module_url=f"{URL_BASE}/entrypoint-{build_id}.js",
+        module_url=f"{URL_BASE}/entrypoint.{build_id}.js",
         embed_iframe=True,
         require_admin=True,
     )

homeassistant/components/ecobee/const.py

@@ -39,7 +39,6 @@ ECOBEE_MODEL_TO_NAME = {
     "vulcanSmart": "ecobee4 Smart",
     "aresSmart": "ecobee Smart Premium",
     "artemisSmart": "ecobee Smart Enhanced",
-    "attisRetail": "ecobee Smart Thermostat with Voice Control",
 }
 
 PLATFORMS = [

homeassistant/components/ekeybionyx/strings.json

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

homeassistant/components/electric_kiwi/strings.json

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

homeassistant/components/environment_canada/camera.py

@@ -76,8 +76,7 @@ class ECCameraEntity(CoordinatorEntity[ECDataUpdateCoordinator[ECRadar]], Camera
         }
         return self.radar_object.image
 
-    async def async_set_radar_type(self, radar_type: str) -> None:
+    async def async_set_radar_type(self, radar_type: str):
         """Set the type of radar to retrieve."""
-        self.radar_object.clear_cache()
         self.radar_object.precip_type = radar_type.lower()
         await self.radar_object.update()

homeassistant/components/environment_canada/manifest.json

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

homeassistant/components/esphome/entry_data.py

@@ -44,7 +44,6 @@ from aioesphomeapi import (
     UpdateInfo,
     UserService,
     ValveInfo,
-    WaterHeaterInfo,
     build_unique_id,
 )
 from aioesphomeapi.model import ButtonInfo
@@ -97,7 +96,6 @@ INFO_TYPE_TO_PLATFORM: dict[type[EntityInfo], Platform] = {
     TimeInfo: Platform.TIME,
     UpdateInfo: Platform.UPDATE,
     ValveInfo: Platform.VALVE,
-    WaterHeaterInfo: Platform.WATER_HEATER,
 }
 
 

homeassistant/components/esphome/manifest.json

@@ -17,9 +17,9 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==43.14.0",
+    "aioesphomeapi==43.10.1",
     "esphome-dashboard-api==1.3.0",
-    "bleak-esphome==3.5.0"
+    "bleak-esphome==3.4.0"
   ],
   "zeroconf": ["_esphomelib._tcp.local."]
 }

homeassistant/components/esphome/sensor.py

@@ -63,7 +63,6 @@ _STATE_CLASSES: EsphomeEnumMapper[EsphomeSensorStateClass, SensorStateClass | No
             EsphomeSensorStateClass.MEASUREMENT: SensorStateClass.MEASUREMENT,
             EsphomeSensorStateClass.TOTAL_INCREASING: SensorStateClass.TOTAL_INCREASING,
             EsphomeSensorStateClass.TOTAL: SensorStateClass.TOTAL,
-            EsphomeSensorStateClass.MEASUREMENT_ANGLE: SensorStateClass.MEASUREMENT_ANGLE,
         }
     )
 )

homeassistant/components/esphome/water_heater.py

@@ -1,110 +0,0 @@
-"""Support for ESPHome water heaters."""
-
-from __future__ import annotations
-
-from functools import partial
-from typing import Any
-
-from aioesphomeapi import EntityInfo, WaterHeaterInfo, WaterHeaterMode, WaterHeaterState
-
-from homeassistant.components.water_heater import (
-    WaterHeaterEntity,
-    WaterHeaterEntityFeature,
-)
-from homeassistant.const import ATTR_TEMPERATURE, PRECISION_TENTHS, UnitOfTemperature
-from homeassistant.core import callback
-
-from .entity import (
-    EsphomeEntity,
-    convert_api_error_ha_error,
-    esphome_float_state_property,
-    esphome_state_property,
-    platform_async_setup_entry,
-)
-from .enum_mapper import EsphomeEnumMapper
-
-PARALLEL_UPDATES = 0
-
-
-_WATER_HEATER_MODES: EsphomeEnumMapper[WaterHeaterMode, str] = EsphomeEnumMapper(
-    {
-        WaterHeaterMode.OFF: "off",
-        WaterHeaterMode.ECO: "eco",
-        WaterHeaterMode.ELECTRIC: "electric",
-        WaterHeaterMode.PERFORMANCE: "performance",
-        WaterHeaterMode.HIGH_DEMAND: "high_demand",
-        WaterHeaterMode.HEAT_PUMP: "heat_pump",
-        WaterHeaterMode.GAS: "gas",
-    }
-)
-
-
-class EsphomeWaterHeater(
-    EsphomeEntity[WaterHeaterInfo, WaterHeaterState], WaterHeaterEntity
-):
-    """A water heater implementation for ESPHome."""
-
-    _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_precision = PRECISION_TENTHS
-
-    @callback
-    def _on_static_info_update(self, static_info: EntityInfo) -> None:
-        """Set attrs from static info."""
-        super()._on_static_info_update(static_info)
-        static_info = self._static_info
-        self._attr_min_temp = static_info.min_temperature
-        self._attr_max_temp = static_info.max_temperature
-        features = WaterHeaterEntityFeature.TARGET_TEMPERATURE
-        if static_info.supported_modes:
-            features |= WaterHeaterEntityFeature.OPERATION_MODE
-            self._attr_operation_list = [
-                _WATER_HEATER_MODES.from_esphome(mode)
-                for mode in static_info.supported_modes
-            ]
-        else:
-            self._attr_operation_list = None
-        self._attr_supported_features = features
-
-    @property
-    @esphome_float_state_property
-    def current_temperature(self) -> float | None:
-        """Return the current temperature."""
-        return self._state.current_temperature
-
-    @property
-    @esphome_float_state_property
-    def target_temperature(self) -> float | None:
-        """Return the temperature we try to reach."""
-        return self._state.target_temperature
-
-    @property
-    @esphome_state_property
-    def current_operation(self) -> str | None:
-        """Return current operation mode."""
-        return _WATER_HEATER_MODES.from_esphome(self._state.mode)
-
-    @convert_api_error_ha_error
-    async def async_set_temperature(self, **kwargs: Any) -> None:
-        """Set new target temperature."""
-        self._client.water_heater_command(
-            key=self._key,
-            target_temperature=kwargs[ATTR_TEMPERATURE],
-            device_id=self._static_info.device_id,
-        )
-
-    @convert_api_error_ha_error
-    async def async_set_operation_mode(self, operation_mode: str) -> None:
-        """Set new operation mode."""
-        self._client.water_heater_command(
-            key=self._key,
-            mode=_WATER_HEATER_MODES.from_hass(operation_mode),
-            device_id=self._static_info.device_id,
-        )
-
-
-async_setup_entry = partial(
-    platform_async_setup_entry,
-    info_type=WaterHeaterInfo,
-    entity_type=EsphomeWaterHeater,
-    state_type=WaterHeaterState,
-)

homeassistant/components/fitbit/strings.json

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

homeassistant/components/freebox/manifest.json

@@ -8,6 +8,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["freebox_api"],
-  "requirements": ["freebox-api==1.3.0"],
+  "requirements": ["freebox-api==1.2.2"],
   "zeroconf": ["_fbx-api._tcp.local."]
 }

homeassistant/components/fritz/coordinator.py

@@ -467,7 +467,8 @@ class FritzBoxTools(DataUpdateCoordinator[UpdateCoordinatorDataType]):
             self._devices[dev_mac].update(dev_info, consider_home)
             return False
 
-        device = FritzDevice(dev_mac, dev_info, consider_home)
+        device = FritzDevice(dev_mac, dev_info.name)
+        device.update(dev_info, consider_home)
         self._devices[dev_mac] = device
 
         # manually register device entry for new connected device

homeassistant/components/fritz/device_tracker.py

@@ -69,8 +69,6 @@ def _async_add_entities(
 class FritzBoxTracker(FritzDeviceBase, ScannerEntity):
     """Class which queries a FRITZ!Box device."""
 
-    _attr_translation_key = "device_tracker"
-
     def __init__(self, avm_wrapper: AvmWrapper, device: FritzDevice) -> None:
         """Initialize a FRITZ!Box device."""
         super().__init__(avm_wrapper, device)
@@ -92,6 +90,13 @@ class FritzBoxTracker(FritzDeviceBase, ScannerEntity):
         """Return mac_address."""
         return self._mac
 
+    @property
+    def icon(self) -> str:
+        """Return device icon."""
+        if self.is_connected:
+            return "mdi:lan-connect"
+        return "mdi:lan-disconnect"
+
     @property
     def extra_state_attributes(self) -> dict[str, str]:
         """Return the attributes."""

homeassistant/components/fritz/entity.py

@@ -33,9 +33,11 @@ class FritzDeviceBase(CoordinatorEntity[AvmWrapper]):
         )
 
     @property
-    def ip_address(self) -> str:
+    def ip_address(self) -> str | None:
         """Return the primary ip address of the device."""
-        return self._avm_wrapper.devices[self._mac].ip_address
+        if self._mac:
+            return self._avm_wrapper.devices[self._mac].ip_address
+        return None
 
     @property
     def mac_address(self) -> str:
@@ -43,9 +45,11 @@ class FritzDeviceBase(CoordinatorEntity[AvmWrapper]):
         return self._mac
 
     @property
-    def hostname(self) -> str:
+    def hostname(self) -> str | None:
         """Return hostname of the device."""
-        return self._avm_wrapper.devices[self._mac].hostname
+        if self._mac:
+            return self._avm_wrapper.devices[self._mac].hostname
+        return None
 
     async def async_process_update(self) -> None:
         """Update device."""

homeassistant/components/fritz/icons.json

@@ -8,14 +8,6 @@
         "default": "mdi:lan-pending"
       }
     },
-    "device_tracker": {
-      "device_tracker": {
-        "default": "mdi:lan-disconnect",
-        "state": {
-          "home": "mdi:lan-connect"
-        }
-      }
-    },
     "sensor": {
       "external_ip": {
         "default": "mdi:earth"

homeassistant/components/fritz/models.py

@@ -77,21 +77,17 @@ class HostInfo(TypedDict):
 class FritzDevice:
     """Representation of a device connected to the FRITZ!Box."""
 
-    _connected: bool
-    _connected_to: str
-    _connection_type: str
-    _ip_address: str
-    _last_activity: datetime | None
-    _mac: str
-    _name: str
-    _ssid: str | None
-    _wan_access: bool | None
-
-    def __init__(self, mac: str, dev_info: Device, consider_home: float) -> None:
+    def __init__(self, mac: str, name: str) -> None:
         """Initialize device info."""
+        self._connected = False
+        self._connected_to: str | None = None
+        self._connection_type: str | None = None
+        self._ip_address: str | None = None
+        self._last_activity: datetime | None = None
         self._mac = mac
-        self._last_activity = None
-        self.update(dev_info, consider_home)
+        self._name = name
+        self._ssid: str | None = None
+        self._wan_access: bool | None = False
 
     def update(self, dev_info: Device, consider_home: float) -> None:
         """Update device info."""
@@ -104,7 +100,8 @@ class FritzDevice:
         else:
             consider_home_evaluated = dev_info.connected
 
-        self._name = dev_info.name or self._mac.replace(":", "_")
+        if not self._name:
+            self._name = dev_info.name or self._mac.replace(":", "_")
 
         self._connected = dev_info.connected or consider_home_evaluated
 
@@ -118,12 +115,12 @@ class FritzDevice:
         self._wan_access = dev_info.wan_access
 
     @property
-    def connected_to(self) -> str:
+    def connected_to(self) -> str | None:
         """Return connected status."""
         return self._connected_to
 
     @property
-    def connection_type(self) -> str:
+    def connection_type(self) -> str | None:
         """Return connected status."""
         return self._connection_type
 
@@ -143,7 +140,7 @@ class FritzDevice:
         return self._name
 
     @property
-    def ip_address(self) -> str:
+    def ip_address(self) -> str | None:
         """Get IP address."""
         return self._ip_address
 
@@ -162,11 +159,6 @@ class FritzDevice:
         """Return device wan access."""
         return self._wan_access
 
-    @wan_access.setter
-    def wan_access(self, allowed: bool) -> None:
-        """Set device wan access."""
-        self._wan_access = allowed
-
 
 class SwitchInfo(TypedDict):
     """FRITZ!Box switch info class."""

homeassistant/components/fritz/switch.py

@@ -382,7 +382,7 @@ class FritzBoxPortSwitch(FritzBoxBaseSwitch):
         self,
         avm_wrapper: AvmWrapper,
         device_friendly_name: str,
-        port_mapping: dict[str, Any],
+        port_mapping: dict[str, Any] | None,
         port_name: str,
         idx: int,
         connection_type: str,
@@ -396,6 +396,9 @@ class FritzBoxPortSwitch(FritzBoxBaseSwitch):
         self._idx = idx  # needed for update routine
         self._attr_entity_category = EntityCategory.CONFIG
 
+        if port_mapping is None:
+            return
+
         switch_info = SwitchInfo(
             description=f"Port forward {port_name}",
             friendly_name=device_friendly_name,
@@ -435,6 +438,9 @@ class FritzBoxPortSwitch(FritzBoxBaseSwitch):
             self._attributes[attr] = self.port_mapping[key]
 
     async def _async_switch_on_off_executor(self, turn_on: bool) -> bool:
+        if self.port_mapping is None:
+            return False
+
         self.port_mapping["NewEnabled"] = "1" if turn_on else "0"
 
         resp = await self._avm_wrapper.async_add_port_mapping(
@@ -488,9 +494,6 @@ class FritzBoxDeflectionSwitch(FritzBoxBaseCoordinatorSwitch):
     async def _async_handle_turn_on_off(self, turn_on: bool) -> None:
         """Handle deflection switch."""
         await self.coordinator.async_set_deflection_enable(self.deflection_id, turn_on)
-        deflection = self.coordinator.data["call_deflections"][self.deflection_id]
-        deflection["Enable"] = "1" if turn_on else "0"
-        self.async_write_ha_state()
 
 
 class FritzBoxProfileSwitch(FritzDeviceBase, SwitchEntity):
@@ -527,8 +530,9 @@ class FritzBoxProfileSwitch(FritzDeviceBase, SwitchEntity):
 
     async def _async_handle_turn_on_off(self, turn_on: bool) -> bool:
         """Handle switch state change request."""
+        if not self.ip_address:
+            return False
         await self._avm_wrapper.async_set_allow_wan_access(self.ip_address, turn_on)
-        self._avm_wrapper.devices[self._mac].wan_access = turn_on
         self.async_write_ha_state()
         return True
 

homeassistant/components/fritzbox/coordinator.py

@@ -87,7 +87,7 @@ class FritzboxDataUpdateCoordinator(DataUpdateCoordinator[FritzboxCoordinatorDat
             self.has_triggers = False
         LOGGER.debug("enable smarthome triggers: %s", self.has_triggers)
 
-        self.configuration_url = self.fritz.base_url
+        self.configuration_url = self.fritz.get_prefixed_host()
 
         await self.async_config_entry_first_refresh()
         self.cleanup_removed_devices(self.data)

homeassistant/components/fritzbox/manifest.json

@@ -7,7 +7,7 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["pyfritzhome"],
-  "requirements": ["pyfritzhome==0.6.19"],
+  "requirements": ["pyfritzhome==0.6.18"],
   "ssdp": [
     {
       "st": "urn:schemas-upnp-org:device:fritzbox:1"

homeassistant/components/frontend/__init__.py

@@ -36,10 +36,7 @@ from homeassistant.helpers.typing import ConfigType
 from homeassistant.loader import async_get_integration, bind_hass
 from homeassistant.util.hass_dict import HassKey
 
-from .storage import (
-    async_setup_frontend_storage,
-    async_system_store as async_system_store,
-)
+from .storage import async_setup_frontend_storage
 
 _LOGGER = logging.getLogger(__name__)
 

homeassistant/components/gentex_homelink/strings.json

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

homeassistant/components/geocaching/strings.json

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

homeassistant/components/go2rtc/__init__.py

@@ -413,53 +413,12 @@ class WebRTCProvider(CameraWebRTCProvider):
                 ],
             )
 
-    async def _update_preload_stream(self, camera: Camera) -> None:
-        camera_prefs = await get_dynamic_camera_stream_settings(
-            self._hass, camera.entity_id
-        )
-        preload_streams = await self._rest_client.preload.list()
-
-        if camera_prefs.preload_stream == (camera.entity_id in preload_streams):
-            return
-
-        if camera_prefs.preload_stream:
-            # We need to first add the stream source otherwise preload enabling will fail
-            await self._update_stream_source(camera)
-            await self._rest_client.preload.enable(camera.entity_id)
-        else:
-            await self._rest_client.preload.disable(camera.entity_id)
-
     async def teardown(self) -> None:
         """Tear down the provider."""
         for ws_client in self._sessions.values():
             await ws_client.close()
         self._sessions.clear()
 
-    async def async_register_camera(
-        self,
-        camera: Camera,
-    ) -> None:
-        """Will be called when the provider is registered for a camera."""
-        await self._update_preload_stream(camera)
-
-    async def async_unregister_camera(
-        self,
-        camera: Camera,
-    ) -> None:
-        """Will be called when the provider is unregistered for a camera."""
-        streams = await self._rest_client.streams.list()
-        if streams.get(camera.entity_id):
-            # If no stream exists, no need to disable preload
-            # as a stream is required to enable preload
-            await self._update_preload_stream(camera)
-
-    async def async_on_camera_prefs_update(
-        self,
-        camera: Camera,
-    ) -> None:
-        """Will be called when the camera preferences are updated."""
-        await self._update_preload_stream(camera)
-
 
 @dataclass
 class Go2RtcConfig:

homeassistant/components/go2rtc/const.py

@@ -8,4 +8,4 @@ HA_MANAGED_API_PORT = 11984
 HA_MANAGED_URL = f"http://localhost:{HA_MANAGED_API_PORT}/"
 # When changing this version, also update the corresponding SHA hash (_GO2RTC_SHA)
 # in script/hassfest/docker.py.
-RECOMMENDED_VERSION = "1.9.14"
+RECOMMENDED_VERSION = "1.9.13"

homeassistant/components/go2rtc/server.py

@@ -74,7 +74,6 @@ _API_ALLOW_PATHS = (
     "/",  # UI static page and version control
     "/api",  # Main API path
     "/api/frame.jpeg",  # Snapshot functionality
-    "/api/preload",  # Preload functionality
     "/api/schemes",  # Supported stream schemes
     "/api/streams",  # Stream management
     "/api/webrtc",  # Webrtc functionality

homeassistant/components/google/calendar.py

@@ -101,7 +101,6 @@ class GoogleCalendarEntityDescription(CalendarEntityDescription):
     search: str | None
     local_sync: bool
     device_id: str
-    initial_color: str | None = None
     event_type: EventTypeEnum | None = None
 
 
@@ -162,7 +161,6 @@ def _get_entity_descriptions(
             local_sync=local_sync,
             entity_registry_enabled_default=entity_enabled,
             device_id=data[CONF_DEVICE_ID],
-            initial_color=calendar_item.background_color,
         )
         entity_descriptions.append(entity_description)
         _LOGGER.debug(
@@ -361,7 +359,6 @@ class GoogleCalendarEntity(
         if entity_description.entity_id:
             self.entity_id = entity_description.entity_id
         self._attr_unique_id = unique_id
-        self._attr_initial_color = entity_description.initial_color
         if not entity_description.read_only:
             self._attr_supported_features = (
                 CalendarEntityFeature.CREATE_EVENT | CalendarEntityFeature.DELETE_EVENT

homeassistant/components/google/strings.json

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

homeassistant/components/google_air_quality/sensor.py

@@ -3,9 +3,8 @@
 from collections.abc import Callable
 from dataclasses import dataclass
 import logging
-from typing import TYPE_CHECKING
 
-from google_air_quality_api.model import AirQualityCurrentConditionsData, Index
+from google_air_quality_api.model import AirQualityCurrentConditionsData
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -34,18 +33,6 @@ _LOGGER = logging.getLogger(__name__)
 PARALLEL_UPDATES = 0
 
 
-def _uaqi(data: AirQualityCurrentConditionsData) -> Index:
-    if TYPE_CHECKING:
-        assert data.indexes.uaqi is not None
-    return data.indexes.uaqi
-
-
-def _laqi(data: AirQualityCurrentConditionsData) -> Index:
-    if TYPE_CHECKING:
-        assert data.indexes.laqi is not None
-    return data.indexes.laqi
-
-
 @dataclass(frozen=True, kw_only=True)
 class AirQualitySensorEntityDescription(SensorEntityDescription):
     """Describes Air Quality sensor entity."""
@@ -69,46 +56,52 @@ AIR_QUALITY_SENSOR_TYPES: tuple[AirQualitySensorEntityDescription, ...] = (
         translation_key="uaqi",
         state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.AQI,
-        value_fn=lambda x: _uaqi(x).aqi,
+        value_fn=lambda x: x.indexes[0].aqi,
     ),
     AirQualitySensorEntityDescription(
         key="uaqi_category",
         translation_key="uaqi_category",
         device_class=SensorDeviceClass.ENUM,
-        value_fn=lambda x: _uaqi(x).category,
-        options_fn=lambda x: _uaqi(x).category_options,
+        options_fn=lambda x: x.indexes[0].category_options,
+        value_fn=lambda x: x.indexes[0].category,
     ),
     AirQualitySensorEntityDescription(
         key="local_aqi",
         translation_key="local_aqi",
-        exists_fn=lambda x: _laqi(x).aqi is not None,
+        exists_fn=lambda x: x.indexes[1].aqi is not None,
         state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.AQI,
-        value_fn=lambda x: _laqi(x).aqi,
-        translation_placeholders_fn=lambda x: {"local_aqi": _laqi(x).display_name},
+        value_fn=lambda x: x.indexes[1].aqi,
+        translation_placeholders_fn=lambda data: {
+            "local_aqi": data.indexes[1].display_name
+        },
     ),
     AirQualitySensorEntityDescription(
         key="local_category",
         translation_key="local_category",
         device_class=SensorDeviceClass.ENUM,
-        value_fn=lambda x: _laqi(x).category,
-        options_fn=lambda x: _laqi(x).category_options,
-        translation_placeholders_fn=lambda x: {"local_aqi": _laqi(x).display_name},
+        value_fn=lambda x: x.indexes[1].category,
+        options_fn=lambda x: x.indexes[1].category_options,
+        translation_placeholders_fn=lambda data: {
+            "local_aqi": data.indexes[1].display_name
+        },
     ),
     AirQualitySensorEntityDescription(
         key="uaqi_dominant_pollutant",
         translation_key="uaqi_dominant_pollutant",
         device_class=SensorDeviceClass.ENUM,
-        value_fn=lambda x: _uaqi(x).dominant_pollutant,
-        options_fn=lambda x: _uaqi(x).pollutant_options,
+        value_fn=lambda x: x.indexes[0].dominant_pollutant,
+        options_fn=lambda x: x.indexes[0].pollutant_options,
     ),
     AirQualitySensorEntityDescription(
         key="local_dominant_pollutant",
         translation_key="local_dominant_pollutant",
         device_class=SensorDeviceClass.ENUM,
-        value_fn=lambda x: _laqi(x).dominant_pollutant,
-        options_fn=lambda x: _laqi(x).pollutant_options,
-        translation_placeholders_fn=lambda x: {"local_aqi": _laqi(x).display_name},
+        value_fn=lambda x: x.indexes[1].dominant_pollutant,
+        options_fn=lambda x: x.indexes[1].pollutant_options,
+        translation_placeholders_fn=lambda data: {
+            "local_aqi": data.indexes[1].display_name
+        },
     ),
     AirQualitySensorEntityDescription(
         key="c6h6",

homeassistant/components/google_assistant_sdk/strings.json

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

homeassistant/components/google_drive/strings.json

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

homeassistant/components/google_generative_ai_conversation/config_flow.py

@@ -305,11 +305,10 @@ async def google_generative_ai_config_option_schema(
         )
         for api in llm.async_get_apis(hass)
     ]
-    if suggested_llm_apis := options.get(CONF_LLM_HASS_API):
-        if isinstance(suggested_llm_apis, str):
-            suggested_llm_apis = [suggested_llm_apis]
-        known_apis = {api.id for api in llm.async_get_apis(hass)}
-        suggested_llm_apis = [api for api in suggested_llm_apis if api in known_apis]
+    if (suggested_llm_apis := options.get(CONF_LLM_HASS_API)) and isinstance(
+        suggested_llm_apis, str
+    ):
+        suggested_llm_apis = [suggested_llm_apis]
 
     if is_new:
         if CONF_NAME in options: