Merge branch 'dev' into mqtt-block-group_entities

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

@@ -1,225 +0,0 @@
----
-name: raise-pull-request
-description: |
-  Use this agent when creating a pull request for the Home Assistant core repository after completing implementation work. This agent automates the PR creation process including running tests, formatting checks, and proper checkbox handling.
-model: inherit
-color: green
-tools: Read, Bash, Grep, Glob
----
-
-You are an expert at creating pull requests for the Home Assistant core repository. You will automate the PR creation process with proper verification, formatting, testing, and checkbox handling.
-
-**Execute each step in order. Do not skip steps.**
-
-## Step 1: Gather Information
-
-Run these commands in parallel to analyze the changes:
-
-```bash
-# Get current branch and remote
-git branch --show-current
-git remote -v | grep push
-
-# Determine the best available dev reference
-if git rev-parse --verify --quiet upstream/dev >/dev/null; then
-  BASE_REF="upstream/dev"
-elif git rev-parse --verify --quiet origin/dev >/dev/null; then
-  BASE_REF="origin/dev"
-elif git rev-parse --verify --quiet dev >/dev/null; then
-  BASE_REF="dev"
-else
-  echo "Could not find upstream/dev, origin/dev, or local dev"
-  exit 1
-fi
-
-BASE_SHA="$(git merge-base "$BASE_REF" HEAD)"
-echo "BASE_REF=$BASE_REF"
-echo "BASE_SHA=$BASE_SHA"
-
-# Get commit info for this branch vs dev
-git log "${BASE_SHA}..HEAD" --oneline
-
-# Check what files changed
-git diff "${BASE_SHA}..HEAD" --name-only
-
-# Check if test files were added/modified
-git diff "${BASE_SHA}..HEAD" --name-only | grep -E "^tests/.*\.py$" || echo "NO_TESTS_CHANGED"
-
-# Check if manifest.json changed
-git diff "${BASE_SHA}..HEAD" --name-only | grep "manifest.json" || echo "NO_MANIFEST_CHANGED"
-```
-
-From the file paths, extract the **integration domain** from `homeassistant/components/{integration}/` or `tests/components/{integration}/`.
-
-**Track results:**
-- `BASE_REF`: the dev reference used for comparison
-- `BASE_SHA`: the merge-base commit used for diff-based checks
-- `TESTS_CHANGED`: true if test files were added or modified
-- `MANIFEST_CHANGED`: true if manifest.json was modified
-
-**If no suitable dev reference is available, STOP and tell the user to fetch `upstream/dev`, `origin/dev`, or a local `dev` branch before continuing.**
-
-## Step 2: Run Code Quality Checks
-
-Run `prek` to perform code quality checks (formatting, linting, hassfest, etc.) on the files changed since `BASE_SHA`:
-
-```bash
-prek run --from-ref "$BASE_SHA" --to-ref HEAD
-```
-
-**Track results:**
-- `PREK_PASSED`: true if `prek run` exits with code 0
-
-**If `prek` fails or is not available, STOP and report the failure to the user. Do not proceed with PR creation. If the failure appears to be an environment setup issue (e.g., missing tools, command not found, venv not activated), also point the user to https://developers.home-assistant.io/docs/development_environment.**
-
-## Step 3: Stage Any Changes from Checks
-
-If `prek` made any formatting or generated file changes, stage and commit them as a separate commit:
-
-```bash
-git status --porcelain
-# If changes exist:
-git add -A
-git commit -m "Apply prek formatting and generated file updates"
-```
-
-## Step 4: Run Tests
-
-Run pytest for the specific integration:
-
-```bash
-pytest tests/components/{integration} \
-  --timeout=60 \
-  --durations-min=1 \
-  --durations=0 \
-  -q
-```
-
-**Track results:**
-- `TESTS_PASSED`: true if pytest exits with code 0
-
-**If tests fail, STOP and report the failures to the user. Do not proceed with PR creation.**
-
-## Step 5: Identify PR Metadata
-
-Write a release-note-style PR title summarizing the change. The title becomes the release notes entry, so it should be a complete sentence fragment describing what changed in imperative mood.
-
-**PR Title Examples by Type:**
-| Type | Example titles |
-|------|----------------|
-| Bugfix | `Fix Hikvision NVR binary sensors not being detected` |
-| | `Fix JSON serialization of time objects in anthropic tool results` |
-| | `Fix config flow bug in Tesla Fleet` |
-| Dependency | `Bump eheimdigital to 1.5.0` |
-| | `Bump python-otbr-api to 2.7.1` |
-| New feature | `Add asyncio-level timeout to Backblaze B2 uploads` |
-| | `Add Nettleie optimization option` |
-| Code quality | `Add exception translations to Teslemetry` |
-| | `Improve test coverage of Tesla Fleet` |
-| | `Refactor adguard tests to use proper fixtures for mocking` |
-| | `Simplify entity init in Proxmox` |
-
-## Step 6: Verify Development Checklist
-
-Check each item from the [development checklist](https://developers.home-assistant.io/docs/development_checklist/):
-
-| Item | How to verify |
-|------|---------------|
-| External libraries on PyPI | Check manifest.json requirements - all should be PyPI packages |
-| Dependencies in requirements_all.txt | Only if dependency declarations changed (the `requirements` field in `manifest.json` or `requirements_all.txt`), run `python -m script.gen_requirements_all` |
-| Codeowners updated | If this is a new integration, ensure its `manifest.json` includes a `codeowners` field with one or more GitHub usernames |
-| No commented out code | Visually scan the diff for blocks of commented-out code |
-
-**Track results:**
-- `NO_COMMENTED_CODE`: true if no blocks of commented-out code found in the diff
-- `DEPENDENCIES_CHANGED`: true if the diff changes the `requirements` field in `manifest.json` or changes `requirements_all.txt`
-- `REQUIREMENTS_UPDATED`: true if `DEPENDENCIES_CHANGED` is true and requirements_all.txt was regenerated successfully; not applicable if `DEPENDENCIES_CHANGED` is false
-- `CHECKLIST_PASSED`: true if all items above pass
-
-## Step 7: Determine Type of Change
-
-Select exactly ONE based on the changes. Mark the selected type with `[x]` and all others with `[ ]` (space):
-
-| Type | Condition |
-|------|-----------|
-| Dependency upgrade | Only manifest.json/requirements changes |
-| Bugfix | Fixes broken behavior, no new features |
-| New integration | New folder in components/ |
-| New feature | Adds capability to existing integration |
-| Deprecation | Adds deprecation warnings for future breaking change |
-| Breaking change | Removes or changes existing functionality |
-| Code quality | Only refactoring or test additions, no functional change |
-
-**Track results:**
-- `CHANGE_TYPE`: the selected type (e.g., "Bugfix", "New feature", "Code quality", etc.)
-
-**Important:** All seven type options must remain in the PR body. Only the selected type gets `[x]`, all others get `[ ]`.
-
-## Step 8: Determine Checkbox States
-
-Based on the verification steps above, determine checkbox states:
-
-| Checkbox | Condition to tick |
-|----------|-------------------|
-| The code change is tested and works locally | Leave unchecked for the contributor to verify manually (this refers to manual testing, not unit tests) |
-| Local tests pass | Tick only if `TESTS_PASSED` is true |
-| I understand the code I am submitting and can explain how it works | Leave unchecked for the contributor to review and set manually |
-| There is no commented out code | Tick only if `NO_COMMENTED_CODE` is true |
-| Development checklist | Tick only if `CHECKLIST_PASSED` is true |
-| Perfect PR recommendations | Tick only if the PR affects a single integration or closely related modules, represents one primary type of change, and has a clear, self-contained scope |
-| Formatted using Ruff | Tick only if `PREK_PASSED` is true |
-| Tests have been added | Tick only if `TESTS_CHANGED` is true AND the changes exercise new or changed functionality (not only cosmetic test changes) |
-| Documentation added/updated | Tick if documentation PR created (or not applicable) |
-| Manifest file fields filled out | Tick if `PREK_PASSED` is true (or not applicable) |
-| Dependencies in requirements_all.txt | Tick only if `DEPENDENCIES_CHANGED` is false, or if `DEPENDENCIES_CHANGED` is true and `REQUIREMENTS_UPDATED` is true |
-| Dependency changelog linked | Tick if dependency changelog linked in PR description (or not applicable) |
-| Any generated code has been carefully reviewed | Leave unchecked for the contributor to review and set manually |
-
-## Step 9: Breaking Change Section
-
-**If `CHANGE_TYPE` is NOT "Breaking change" or "Deprecation": REMOVE the entire "## Breaking change" section from the PR body (including the heading).**
-
-If `CHANGE_TYPE` IS "Breaking change" or "Deprecation", keep the `## Breaking change` section and describe:
-- What breaks
-- How users can fix it
-- Why it was necessary
-
-## Step 10: Push Branch and Create PR
-
-Push the branch with upstream tracking, and create a PR against `home-assistant/core` with the generated title and body:
-
-```bash
-# Create PR (gh pr create pushes the branch automatically)
-gh pr create --repo home-assistant/core --base dev \
-  --draft \
-  --title "TITLE_HERE" \
-  --body "$(cat <<'EOF'
-BODY_HERE
-EOF
-)"
-```
-
-### PR Body Template
-
-Read the PR template from `.github/PULL_REQUEST_TEMPLATE.md` and use it as the basis for the PR body. **Do not hardcode the template — always read it from the file to stay in sync with upstream changes.**
-
-Use any HTML comments (`<!-- ... -->`) in the template as guidance to understand what to fill in. For the final PR body sent to GitHub, keep the template text intact — do not delete any text from the template unless it explicitly instructs removal (e.g., the breaking change section when not applicable). Then fill in the sections:
-
-1. **Breaking change section**: If the type is NOT "Breaking change" or "Deprecation", remove the entire `## Breaking change` section (heading and body). Otherwise, describe what breaks, how users can fix it, and why.
-2. **Proposed change section**: Fill in a description of the change extracted from commit messages.
-3. **Type of change**: Check exactly ONE checkbox matching the determined type from Step 7. Leave all others unchecked.
-4. **Additional information**: Fill in any related issue numbers if known.
-5. **Checklist**: Check boxes based on the conditions in Step 8. Leave manual-verification boxes unchecked for the contributor.
-
-**Important:** Preserve all template structure, options, and link references exactly as they appear in the file — only modify checkbox states and fill in content sections.
-
-## Step 11: Report Result
-
-Provide the user with:
-1. **PR URL** - The created pull request link
-2. **Verification Summary** - Which checks passed/failed
-3. **Unchecked Items** - List any checkboxes left unchecked and why
-4. **User Action Required** - Remind user to:
-   - Review and set manual-verification checkboxes ("I understand the code..." and "Any generated code...") as applicable
-   - Consider reviewing two other open PRs
-   - Add any related issue numbers if applicable

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

@@ -1,10 +1,18 @@
 ---
 name: github-pr-reviewer
-description: Reviews GitHub pull requests and provides feedback comments. This is the top skill to use for reviewing Pull Requests from GitHub.
+description: Review a GitHub pull request and provide feedback comments. Use when the user says "review the current PR" or asks to review a specific PR.
 ---
 
 # Review GitHub Pull Request
 
+## Preparation:
+- Check if the local commit matches the last one in the PR. If not, checkout the PR locally using 'gh pr checkout'. 
+- CRITICAL: If 'gh pr checkout' fails for ANY reason, you MUST immediately STOP.
+    - Do NOT attempt any workarounds. 
+    - Do NOT proceed with the review.
+    - ALERT about the failure and WAIT for instructions.
+    - This is a hard requirement - no exceptions.
+
 ## Follow these steps:
 1. Use 'gh pr view' to get the PR details and description.
 2. Use 'gh pr diff' to see all the changes in the PR.
@@ -27,13 +35,12 @@ description: Reviews GitHub pull requests and provides feedback comments. This i
 - No need to highlight things that are already good.
 
 ## Output format:
-- List specific comments for each file/line that needs attention.
+- List specific comments for each file/line that needs attention
 - In the end, summarize with an overall assessment (approve, request changes, or comment) and bullet point list of changes suggested, if any.
   - Example output:
     ```
     Overall assessment: request changes.
-    - [CRITICAL] sensor.py:143 - Memory leak
-    - [PROBLEM] data_processing.py:87 - Inefficient algorithm
-    - [SUGGESTION] test_init.py:45 - Improve x variable name
+    - [CRITICAL] Memory leak in homeassistant/components/sensor/my_sensor.py:143
+    - [PROBLEM] Inefficient algorithm in homeassistant/helpers/data_processing.py:87
+    - [SUGGESTION] Improve variable naming in homeassistant/helpers/config_validation.py:45
     ```
-  - Make sure to include the file and line number when possible in the bullet points.

.claude/skills/ha-integration-knowledge/SKILL.md

@@ -1,44 +0,0 @@
----
-name: ha-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>/`
-
-## General guidelines
-
-- When looking for examples, prefer integrations with the platinum or gold quality scale level first.
-- Polling intervals are NOT user-configurable. Never add scan_interval, update_interval, or polling frequency options to config flows or config entries.
-- Do NOT allow users to set config entry names in config flows. Names are automatically generated or can be customized later in UI. Exception: helper integrations may allow custom names.
-- For entity actions and entity services, avoid requesting redundant defensive checks for fields already enforced by Home Assistant validation schemas and entity filters; only request extra guards when values bypass validation or are transformed unsafely.
-- When validation guarantees a key is present, prefer direct dictionary indexing (`data["key"]`) over `.get("key")` so invalid assumptions fail fast.
-- Integrations should be thin wrappers. Protocol parsing, device state machines, or other domain logic belong in a separate PyPI library, not in the integration itself. If unsure, ask before inlining.
-- "potato" is a forbidden word for an integration and should never be used.
-
-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
-
-
-## Integration Quality Scale
-
-- When validating the quality scale rules, check them at https://developers.home-assistant.io/docs/core/integration-quality-scale/rules
-- When implementing or reviewing an integration, always consider the quality scale rules, since they promote best practices.
-
-Template scale file: `./script/scaffold/templates/integration/integration/quality_scale.yaml`
-
-### 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
-
-
-## Testing Requirements
-
-- Tests should avoid interacting or mocking internal integration details. For more info, see https://developers.home-assistant.io/docs/development_testing/#writing-tests-for-integrations

.claude/skills/ha-integration-knowledge/platform-diagnostics.md

@@ -1,6 +0,0 @@
-# Integration Diagnostics
-
-Platform exists as `homeassistant/components/<domain>/diagnostics.py`.
-
-- **Required**: Implement diagnostic data collection
-- **Security**: Never expose passwords, tokens, or sensitive coordinates

.claude/skills/ha-integration-knowledge/platform-repairs.md

@@ -1,21 +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.)
-- **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
-- Only create issues for problems users can potentially resolve

.claude/skills/integrations/SKILL.md

@@ -0,0 +1,786 @@
+---
+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
+- **Patch Boundaries**: Only patch library or client methods when testing config flows. Do not patch methods defined in `config_flow.py`; exercise the flow logic end-to-end.
+- **Test Scenarios**:
+  - All flow initiation methods (user, discovery, import)
+  - Successful configuration paths
+  - Error recovery scenarios
+  - Prevention of duplicate entries
+  - Flow completion after errors
+  - Reauthentication/reconfigure flows
+
+### Testing
+- **Integration-specific tests** (recommended):
+  ```bash
+  pytest ./tests/components/<integration_domain> \
+    --cov=homeassistant.components.<integration_domain> \
+    --cov-report term-missing \
+    --durations-min=1 \
+    --durations=0 \
+    --numprocesses=auto
+  ```
+
+### Testing Best Practices
+- **Never access `hass.data` directly** - Use fixtures and proper integration setup instead
+- **Use snapshot testing** - For verifying entity states and attributes
+- **Test through integration setup** - Don't test entities in isolation
+- **Mock external APIs** - Use fixtures with realistic JSON data
+- **Verify registries** - Ensure entities are properly registered with devices
+
+### Config Flow Testing Template
+```python
+async def test_user_flow_success(hass, mock_api):
+    """Test successful user flow."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["step_id"] == "user"
+
+    # Test form submission
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=TEST_USER_INPUT
+    )
+    assert result["type"] == FlowResultType.CREATE_ENTRY
+    assert result["title"] == "My Device"
+    assert result["data"] == TEST_USER_INPUT
+
+async def test_flow_connection_error(hass, mock_api_error):
+    """Test connection error handling."""
+    result = await hass.config_entries.flow.async_init(
+        DOMAIN, context={"source": config_entries.SOURCE_USER}
+    )
+    result = await hass.config_entries.flow.async_configure(
+        result["flow_id"], user_input=TEST_USER_INPUT
+    )
+    assert result["type"] == FlowResultType.FORM
+    assert result["errors"] == {"base": "cannot_connect"}
+```
+
+### Entity Testing Patterns
+```python
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Overridden fixture to specify platforms to test."""
+    return [Platform.SENSOR]  # Or another specific platform as needed.
+
+@pytest.mark.usefixtures("entity_registry_enabled_by_default", "init_integration")
+async def test_entities(
+    hass: HomeAssistant,
+    snapshot: SnapshotAssertion,
+    entity_registry: er.EntityRegistry,
+    device_registry: dr.DeviceRegistry,
+    mock_config_entry: MockConfigEntry,
+) -> None:
+    """Test the sensor entities."""
+    await snapshot_platform(hass, entity_registry, snapshot, mock_config_entry.entry_id)
+
+    # Ensure entities are correctly assigned to device
+    device_entry = device_registry.async_get_device(
+        identifiers={(DOMAIN, "device_unique_id")}
+    )
+    assert device_entry
+    entity_entries = er.async_entries_for_config_entry(
+        entity_registry, mock_config_entry.entry_id
+    )
+    for entity_entry in entity_entries:
+        assert entity_entry.device_id == device_entry.id
+```
+
+### Mock Patterns
+```python
+# Modern integration fixture setup
+@pytest.fixture
+def mock_config_entry() -> MockConfigEntry:
+    """Return the default mocked config entry."""
+    return MockConfigEntry(
+        title="My Integration",
+        domain=DOMAIN,
+        data={CONF_HOST: "127.0.0.1", CONF_API_KEY: "test_key"},
+        unique_id="device_unique_id",
+    )
+
+@pytest.fixture
+def mock_device_api() -> Generator[MagicMock]:
+    """Return a mocked device API."""
+    with patch("homeassistant.components.my_integration.MyDeviceAPI", autospec=True) as api_mock:
+        api = api_mock.return_value
+        api.get_data.return_value = MyDeviceData.from_json(
+            load_fixture("device_data.json", DOMAIN)
+        )
+        yield api
+
+@pytest.fixture
+def platforms() -> list[Platform]:
+    """Fixture to specify platforms to test."""
+    return PLATFORMS
+
+@pytest.fixture
+async def init_integration(
+    hass: HomeAssistant,
+    mock_config_entry: MockConfigEntry,
+    mock_device_api: MagicMock,
+    platforms: list[Platform],
+) -> MockConfigEntry:
+    """Set up the integration for testing."""
+    mock_config_entry.add_to_hass(hass)
+
+    with patch("homeassistant.components.my_integration.PLATFORMS", platforms):
+        await hass.config_entries.async_setup(mock_config_entry.entry_id)
+        await hass.async_block_till_done()
+
+    return mock_config_entry
+```
+
+## Debugging & Troubleshooting
+
+### Common Issues & Solutions
+- **Integration won't load**: Check `manifest.json` syntax and required fields
+- **Entities not appearing**: Verify `unique_id` and `has_entity_name` implementation
+- **Config flow errors**: Check `strings.json` entries and error handling
+- **Discovery not working**: Verify manifest discovery configuration and callbacks
+- **Tests failing**: Check mock setup and async context
+
+### Debug Logging Setup
+```python
+# Enable debug logging in tests
+caplog.set_level(logging.DEBUG, logger="my_integration")
+
+# In integration code - use proper logging
+_LOGGER = logging.getLogger(__name__)
+_LOGGER.debug("Processing data: %s", data)  # Use lazy logging
+```
+
+### Validation Commands
+```bash
+# Check specific integration
+python -m script.hassfest --integration-path homeassistant/components/my_integration
+
+# Validate quality scale
+# Check quality_scale.yaml against current rules
+
+# Run integration tests with coverage
+pytest ./tests/components/my_integration \
+  --cov=homeassistant.components.my_integration \
+  --cov-report term-missing
+```

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

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

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

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

.core_files.yaml

@@ -36,7 +36,6 @@ base_platforms: &base_platforms
   - homeassistant/components/image_processing/**
   - homeassistant/components/infrared/**
   - homeassistant/components/lawn_mower/**
-  - homeassistant/components/radio_frequency/**
   - homeassistant/components/light/**
   - homeassistant/components/lock/**
   - homeassistant/components/media_player/**

.github/copilot-instructions.md

@@ -5,15 +5,16 @@
 # Copilot code review instructions
 
 - Start review comments with a short, one-sentence summary of the suggested fix.
-- Do not comment on code style, formatting or linting issues.
+- Do not add comments about code style, formatting or linting issues.
 
 # GitHub Copilot & Claude Code Instructions
 
 This repository contains the core of Home Assistant, a Python 3 based home automation application.
 
-## Git Commit Guidelines
+## Code Review Guidelines
 
-- **Do NOT amend, squash, or rebase commits that have already been pushed to the PR branch after the PR is opened** - Reviewers need to follow the commit history, as well as see what changed since their last review
+**Git commit practices during review:**
+- **Do NOT amend, squash, or rebase commits after review has started** - Reviewers need to see what changed since their last review
 
 ## Development Commands
 
@@ -21,7 +22,7 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 
 ## Python Syntax Notes
 
-- Python 3.14 explicitly allows `except TypeA, TypeB:` without parentheses. Never flag this as an issue since Home Assistant officially supports Python 3.14.
+- Python 3.14 explicitly allows `except TypeA, TypeB:` without parentheses.
 
 ## Testing
 
@@ -32,5 +33,7 @@ Prefer concrete types (for example, `HomeAssistant`, `MockConfigEntry`, etc.) ov
 
 Integrations with Platinum or Gold level in the Integration Quality Scale reflect a high standard of code quality and maintainability. When looking for examples of something, these are good places to start. The level is indicated in the manifest.json of the integration.
 
-When reviewing entity actions, do not suggest extra defensive checks for input fields that are already validated by Home Assistant's service/action schemas and entity selection filters. Suggest additional guards only when data bypasses those validators or is transformed into a less-safe form.
-When validation guarantees a dict key exists, prefer direct key access (`data["key"]`) instead of `.get("key")` so contract violations are surfaced instead of silently masked.
+
+# Skills
+
+- Home Assistant Integration knowledge: .claude/skills/integrations/SKILL.md

.github/instructions/integrations.instructions.md

@@ -1,47 +0,0 @@
----
-applyTo: "homeassistant/components/**, tests/components/**"
-excludeAgent: "cloud-agent"
----
-
-<!-- Automatically generated by gen_copilot_instructions.py, do not edit -->
-
-
-## File Locations
-- **Integration code**: `./homeassistant/components/<integration_domain>/`
-- **Integration tests**: `./tests/components/<integration_domain>/`
-
-## General guidelines
-
-- When looking for examples, prefer integrations with the platinum or gold quality scale level first.
-- Polling intervals are NOT user-configurable. Never add scan_interval, update_interval, or polling frequency options to config flows or config entries.
-- Do NOT allow users to set config entry names in config flows. Names are automatically generated or can be customized later in UI. Exception: helper integrations may allow custom names.
-- For entity actions and entity services, avoid requesting redundant defensive checks for fields already enforced by Home Assistant validation schemas and entity filters; only request extra guards when values bypass validation or are transformed unsafely.
-- When validation guarantees a key is present, prefer direct dictionary indexing (`data["key"]`) over `.get("key")` so invalid assumptions fail fast.
-- Integrations should be thin wrappers. Protocol parsing, device state machines, or other domain logic belong in a separate PyPI library, not in the integration itself. If unsure, ask before inlining.
-- "potato" is a forbidden word for an integration and should never be used.
-
-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
-
-
-## Integration Quality Scale
-
-- When validating the quality scale rules, check them at https://developers.home-assistant.io/docs/core/integration-quality-scale/rules
-- When implementing or reviewing an integration, always consider the quality scale rules, since they promote best practices.
-
-Template scale file: `./script/scaffold/templates/integration/integration/quality_scale.yaml`
-
-### 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
-
-
-## Testing Requirements
-
-- Tests should avoid interacting or mocking internal integration details. For more info, see https://developers.home-assistant.io/docs/development_testing/#writing-tests-for-integrations

.github/renovate.json

@@ -1,216 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:recommended"],
-
-  "enabledManagers": [
-    "pep621",
-    "pip_requirements",
-    "pre-commit",
-    "regex",
-    "homeassistant-manifest"
-  ],
-
-  "pre-commit": {
-    "enabled": true
-  },
-
-  "pip_requirements": {
-    "managerFilePatterns": [
-      "/(^|/)requirements[\\w_-]*\\.txt$/",
-      "/(^|/)homeassistant/package_constraints\\.txt$/"
-    ]
-  },
-
-  "homeassistant-manifest": {
-    "managerFilePatterns": [
-      "/^homeassistant/components/[^/]+/manifest\\.json$/"
-    ]
-  },
-
-  "regexManagers": [
-    {
-      "description": "Update ruff required-version in pyproject.toml",
-      "managerFilePatterns": ["/^pyproject\\.toml$/"],
-      "matchStrings": ["required-version = \">=(?<currentValue>[\\d.]+)\""],
-      "depNameTemplate": "ruff",
-      "datasourceTemplate": "pypi"
-    }
-  ],
-
-  "minimumReleaseAge": "7 days",
-  "prConcurrentLimit": 10,
-  "prHourlyLimit": 2,
-  "schedule": ["before 6am"],
-
-  "semanticCommits": "disabled",
-  "commitMessageAction": "Update",
-  "commitMessageTopic": "{{depName}}",
-  "commitMessageExtra": "to {{newVersion}}",
-
-  "automerge": false,
-
-  "vulnerabilityAlerts": {
-    "enabled": false
-  },
-
-  "packageRules": [
-    {
-      "description": "Deny all by default — allowlist below re-enables specific packages",
-      "matchPackageNames": ["*"],
-      "enabled": false
-    },
-    {
-      "description": "Core runtime dependencies (allowlisted)",
-      "matchPackageNames": [
-        "aiohttp",
-        "aiohttp-fast-zlib",
-        "aiohttp_cors",
-        "aiohttp-asyncmdnsresolver",
-        "yarl",
-        "httpx",
-        "requests",
-        "urllib3",
-        "certifi",
-        "orjson",
-        "PyYAML",
-        "Jinja2",
-        "cryptography",
-        "pyOpenSSL",
-        "PyJWT",
-        "SQLAlchemy",
-        "Pillow",
-        "attrs",
-        "uv",
-        "voluptuous",
-        "voluptuous-serialize",
-        "voluptuous-openapi",
-        "zeroconf"
-      ],
-      "enabled": true,
-      "labels": ["dependency", "core"]
-    },
-    {
-      "description": "Common Python utilities (allowlisted)",
-      "matchPackageNames": [
-        "astral",
-        "atomicwrites-homeassistant",
-        "audioop-lts",
-        "awesomeversion",
-        "bcrypt",
-        "ciso8601",
-        "cronsim",
-        "defusedxml",
-        "fnv-hash-fast",
-        "getmac",
-        "ical",
-        "ifaddr",
-        "lru-dict",
-        "mutagen",
-        "propcache",
-        "pyserial",
-        "python-slugify",
-        "PyTurboJPEG",
-        "securetar",
-        "standard-aifc",
-        "standard-telnetlib",
-        "ulid-transform",
-        "url-normalize",
-        "xmltodict"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Home Assistant ecosystem packages (core-maintained, no cooldown)",
-      "matchPackageNames": [
-        "hassil",
-        "home-assistant-bluetooth",
-        "home-assistant-frontend",
-        "home-assistant-intents",
-        "infrared-protocols"
-      ],
-      "enabled": true,
-      "minimumReleaseAge": null,
-      "labels": ["dependency", "core"]
-    },
-    {
-      "description": "Test dependencies (allowlisted)",
-      "matchPackageNames": [
-        "pytest",
-        "pytest-asyncio",
-        "pytest-aiohttp",
-        "pytest-cov",
-        "pytest-freezer",
-        "pytest-github-actions-annotate-failures",
-        "pytest-socket",
-        "pytest-sugar",
-        "pytest-timeout",
-        "pytest-unordered",
-        "pytest-picked",
-        "pytest-xdist",
-        "pylint",
-        "pylint-per-file-ignores",
-        "astroid",
-        "coverage",
-        "freezegun",
-        "syrupy",
-        "respx",
-        "requests-mock",
-        "ruff",
-        "codespell",
-        "yamllint",
-        "zizmor"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "For types-* stubs, only allow patch updates. Major/minor bumps track the upstream runtime package version and must be manually coordinated with the corresponding pin.",
-      "matchPackageNames": ["/^types-/"],
-      "matchUpdateTypes": ["patch"],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Pre-commit hook repos (allowlisted, matched by owner/repo)",
-      "matchPackageNames": [
-        "astral-sh/ruff-pre-commit",
-        "codespell-project/codespell",
-        "adrienverge/yamllint",
-        "zizmorcore/zizmor-pre-commit"
-      ],
-      "enabled": true,
-      "labels": ["dependency"]
-    },
-    {
-      "description": "Group ruff pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["astral-sh/ruff-pre-commit", "ruff"],
-      "groupName": "ruff",
-      "groupSlug": "ruff"
-    },
-    {
-      "description": "Group codespell pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["codespell-project/codespell", "codespell"],
-      "groupName": "codespell",
-      "groupSlug": "codespell"
-    },
-    {
-      "description": "Group yamllint pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["adrienverge/yamllint", "yamllint"],
-      "groupName": "yamllint",
-      "groupSlug": "yamllint"
-    },
-    {
-      "description": "Group zizmor pre-commit hook with its PyPI twin into one PR",
-      "matchPackageNames": ["zizmorcore/zizmor-pre-commit", "zizmor"],
-      "groupName": "zizmor",
-      "groupSlug": "zizmor"
-    },
-    {
-      "description": "Group pylint with astroid (their versions are linked and must move together)",
-      "matchPackageNames": ["pylint", "astroid"],
-      "groupName": "pylint",
-      "groupSlug": "pylint"
-    }
-  ]
-}

.github/workflows/builder.yml

@@ -14,7 +14,7 @@ env:
   UV_HTTP_TIMEOUT: 60
   UV_SYSTEM_PYTHON: "true"
   # Base image version from https://github.com/home-assistant/docker
-  BASE_IMAGE_VERSION: "2026.02.0"
+  BASE_IMAGE_VERSION: "2026.01.0"
   ARCHITECTURES: '["amd64", "aarch64"]'
 
 permissions: {}
@@ -47,6 +47,10 @@ jobs:
         with:
           python-version-file: ".python-version"
 
+      - name: Get information
+        id: info
+        uses: home-assistant/actions/helpers/info@master # zizmor: ignore[unpinned-uses]
+
       - name: Get version
         id: version
         uses: home-assistant/actions/helpers/version@master # zizmor: ignore[unpinned-uses]
@@ -76,7 +80,7 @@ jobs:
         run: find ./homeassistant/components/*/translations -name "*.json" | tar zcvf translations.tar.gz -T -
 
       - name: Upload translations
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: translations
           path: translations.tar.gz
@@ -108,7 +112,7 @@ jobs:
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@8305c0f1062bb0d184d09ef4493ecb9288447732 # v20
+        uses: dawidd6/action-download-artifact@8a338493df3d275e4a7a63bcff3b8fe97e51a927 # v19
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -119,7 +123,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@8305c0f1062bb0d184d09ef4493ecb9288447732 # v20
+        uses: dawidd6/action-download-artifact@8a338493df3d275e4a7a63bcff3b8fe97e51a927 # v19
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: OHF-Voice/intents-package
@@ -338,19 +342,19 @@ jobs:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
       - name: Install Cosign
-        uses: sigstore/cosign-installer@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
+        uses: sigstore/cosign-installer@ba7bc0a3fef59531c69a25acd34668d6d3fe6f22 # v4.1.0
         with:
           cosign-release: "v2.5.3"
 
       - name: Login to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -499,7 +503,7 @@ jobs:
           python -m build
 
       - name: Upload package to PyPI
-        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0
+        uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0
         with:
           skip-existing: true
 
@@ -523,14 +527,14 @@ jobs:
           persist-credentials: false
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@4907a6ddec9925e35a0a9e82d7399ccc52663121 # v4.1.0
+        uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build Docker image
-        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
         with:
           context: . # So action will not pull the repository again
           file: ./script/hassfest/docker/Dockerfile
@@ -543,7 +547,7 @@ jobs:
       - name: Push Docker image
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
         id: push
-        uses: docker/build-push-action@bcafcacb16a39f128d818304e6c9c0c18556b85f # v7.1.0
+        uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
         with:
           context: . # So action will not pull the repository again
           file: ./script/hassfest/docker/Dockerfile

.github/workflows/ci.yaml

@@ -50,11 +50,9 @@ env:
   # - 10.10.3 is the latest (as of 6 Feb 2023)
   # 10.11 is the latest long-term-support
   # - 10.11.2 is the version currently shipped with Synology (as of 11 Oct 2023)
-  # 11.4 is an LTS with support until May 2029
-  # - 11.4.9 is used in Alpine 3.23 (used in latest HA base images as of 11 Apr 2026)
   # mysql 8.0.32 does not always behave the same as MariaDB
   # and some queries that work on MariaDB do not work on MySQL
-  MARIADB_VERSIONS: "['mariadb:10.3.32','mariadb:10.6.10','mariadb:10.10.3','mariadb:10.11.2','mariadb:11.4.9','mysql:8.0.32']"
+  MARIADB_VERSIONS: "['mariadb:10.3.32','mariadb:10.6.10','mariadb:10.10.3','mariadb:10.11.2','mysql:8.0.32']"
   # 12 is the oldest supported version
   # - 12.14 is the latest (as of 9 Feb 2023)
   # 15 is the latest version
@@ -282,7 +280,7 @@ jobs:
           echo "::add-matcher::.github/workflows/matchers/check-executables-have-shebangs.json"
           echo "::add-matcher::.github/workflows/matchers/codespell.json"
       - name: Run prek
-        uses: j178/prek-action@cbc2f23eb5539cf20d82d1aabd0d0ecbcc56f4e3 # v2.0.2
+        uses: j178/prek-action@79f765515bd648eb4d6bb1b17277b7cb22cb6468 # v2.0.0
         env:
           PREK_SKIP: no-commit-to-branch,mypy,pylint,gen_requirements_all,hassfest,hassfest-metadata,hassfest-mypy-config,zizmor
           RUFF_OUTPUT_FORMAT: github
@@ -303,7 +301,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Run zizmor
-        uses: j178/prek-action@cbc2f23eb5539cf20d82d1aabd0d0ecbcc56f4e3 # v2.0.2
+        uses: j178/prek-action@79f765515bd648eb4d6bb1b17277b7cb22cb6468 # v2.0.0
         with:
           extra-args: --all-files zizmor
 
@@ -366,7 +364,7 @@ jobs:
           echo "key=uv-${UV_CACHE_VERSION}-${uv_version}-${HA_SHORT_VERSION}-$(date -u '+%Y-%m-%dT%H:%M:%s')" >> $GITHUB_OUTPUT
       - name: Restore base Python virtual environment
         id: cache-venv
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           key: >-
@@ -374,7 +372,7 @@ jobs:
             needs.info.outputs.python_cache_key }}
       - name: Restore uv wheel cache
         if: steps.cache-venv.outputs.cache-hit != 'true'
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: ${{ env.UV_CACHE_DIR }}
           key: >-
@@ -386,7 +384,7 @@ jobs:
             env.HA_SHORT_VERSION }}-
       - name: Check if apt cache exists
         id: cache-apt-check
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           lookup-only: ${{ steps.cache-venv.outputs.cache-hit == 'true' }}
           path: |
@@ -432,7 +430,7 @@ jobs:
           fi
       - name: Save apt cache
         if: steps.cache-apt-check.outputs.cache-hit != 'true'
-        uses: actions/cache/save@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/save@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: |
             ${{ env.APT_CACHE_DIR }}
@@ -458,7 +456,7 @@ jobs:
           python --version
           uv pip freeze >> pip_freeze.txt
       - name: Upload pip_freeze artifact
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: pip-freeze-${{ matrix.python-version }}
           path: pip_freeze.txt
@@ -486,7 +484,7 @@ jobs:
       && github.event.inputs.audit-licenses-only != 'true'
     steps:
       - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: |
             ${{ env.APT_CACHE_DIR }}
@@ -517,7 +515,7 @@ jobs:
           check-latest: true
       - name: Restore full Python virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -554,7 +552,7 @@ jobs:
           check-latest: true
       - name: Restore full Python virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -645,7 +643,7 @@ jobs:
           check-latest: true
       - name: Restore full Python ${{ matrix.python-version }} virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -659,7 +657,7 @@ jobs:
           . venv/bin/activate
           python -m script.licenses extract --output-file=licenses-${PYTHON_VERSION}.json
       - name: Upload licenses
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: licenses-${{ github.run_number }}-${{ matrix.python-version }}
           path: licenses-${{ matrix.python-version }}.json
@@ -696,7 +694,7 @@ jobs:
           check-latest: true
       - name: Restore full Python virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -749,7 +747,7 @@ jobs:
           check-latest: true
       - name: Restore full Python virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -806,7 +804,7 @@ jobs:
           echo "key=mypy-${MYPY_CACHE_VERSION}-${mypy_version}-${HA_SHORT_VERSION}-$(date -u '+%Y-%m-%dT%H:%M:%s')" >> $GITHUB_OUTPUT
       - name: Restore full Python virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -814,7 +812,7 @@ jobs:
             ${{ runner.os }}-${{ runner.arch }}-${{ steps.python.outputs.python-version }}-${{
             needs.info.outputs.python_cache_key }}
       - name: Restore mypy cache
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: .mypy_cache
           key: >-
@@ -856,7 +854,7 @@ jobs:
       - base
     steps:
       - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: |
             ${{ env.APT_CACHE_DIR }}
@@ -889,7 +887,7 @@ jobs:
           check-latest: true
       - name: Restore full Python virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -903,7 +901,7 @@ jobs:
           . venv/bin/activate
           python -m script.split_tests ${TEST_GROUP_COUNT} tests
       - name: Upload pytest_buckets
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: pytest_buckets
           path: pytest_buckets.txt
@@ -932,7 +930,7 @@ jobs:
         group: ${{ fromJson(needs.info.outputs.test_groups) }}
     steps:
       - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: |
             ${{ env.APT_CACHE_DIR }}
@@ -966,7 +964,7 @@ jobs:
           check-latest: true
       - name: Restore full Python ${{ matrix.python-version }} virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -1022,14 +1020,14 @@ jobs:
               2>&1 | tee pytest-${PYTHON_VERSION}-${TEST_GROUP}.txt
       - name: Upload pytest output
         if: success() || failure() && steps.pytest-full.conclusion == 'failure'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: pytest-${{ github.run_number }}-${{ matrix.python-version }}-${{ matrix.group }}
           path: pytest-*.txt
           overwrite: true
       - name: Upload coverage artifact
         if: needs.info.outputs.skip_coverage != 'true'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: coverage-${{ matrix.python-version }}-${{ matrix.group }}
           path: coverage.xml
@@ -1042,7 +1040,7 @@ jobs:
           mv "junit.xml-tmp" "junit.xml"
       - name: Upload test results artifact
         if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: test-results-full-${{ matrix.python-version }}-${{ matrix.group }}
           path: junit.xml
@@ -1064,9 +1062,7 @@ jobs:
           - 3306:3306
         env:
           MYSQL_ROOT_PASSWORD: password
-        options: >-
-          --health-cmd="if command -v mariadb-admin >/dev/null; then mariadb-admin ping -uroot -ppassword; else mysqladmin ping -uroot -ppassword; fi"
-          --health-interval=5s --health-timeout=2s --health-retries=3
+        options: --health-cmd="mysqladmin ping -uroot -ppassword" --health-interval=5s --health-timeout=2s --health-retries=3
     needs:
       - info
       - base
@@ -1084,7 +1080,7 @@ jobs:
         mariadb-group: ${{ fromJson(needs.info.outputs.mariadb_groups) }}
     steps:
       - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: |
             ${{ env.APT_CACHE_DIR }}
@@ -1119,7 +1115,7 @@ jobs:
           check-latest: true
       - name: Restore full Python ${{ matrix.python-version }} virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -1181,7 +1177,7 @@ jobs:
               2>&1 | tee pytest-${PYTHON_VERSION}-${mariadb}.txt
       - name: Upload pytest output
         if: success() || failure() && steps.pytest-partial.conclusion == 'failure'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: pytest-${{ github.run_number }}-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.mariadb }}
@@ -1189,7 +1185,7 @@ jobs:
           overwrite: true
       - name: Upload coverage artifact
         if: needs.info.outputs.skip_coverage != 'true'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: coverage-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.mariadb }}
@@ -1203,7 +1199,7 @@ jobs:
           mv "junit.xml-tmp" "junit.xml"
       - name: Upload test results artifact
         if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: test-results-mariadb-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.mariadb }}
@@ -1242,7 +1238,7 @@ jobs:
         postgresql-group: ${{ fromJson(needs.info.outputs.postgresql_groups) }}
     steps:
       - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: |
             ${{ env.APT_CACHE_DIR }}
@@ -1279,7 +1275,7 @@ jobs:
           check-latest: true
       - name: Restore full Python ${{ matrix.python-version }} virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -1342,7 +1338,7 @@ jobs:
               2>&1 | tee pytest-${PYTHON_VERSION}-${postgresql}.txt
       - name: Upload pytest output
         if: success() || failure() && steps.pytest-partial.conclusion == 'failure'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: pytest-${{ github.run_number }}-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.postgresql }}
@@ -1350,7 +1346,7 @@ jobs:
           overwrite: true
       - name: Upload coverage artifact
         if: needs.info.outputs.skip_coverage != 'true'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: coverage-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.postgresql }}
@@ -1364,7 +1360,7 @@ jobs:
           mv "junit.xml-tmp" "junit.xml"
       - name: Upload test results artifact
         if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: test-results-postgres-${{ matrix.python-version }}-${{
             steps.pytest-partial.outputs.postgresql }}
@@ -1396,7 +1392,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'true'
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
         with:
           fail_ci_if_error: true
           flags: full-suite
@@ -1425,7 +1421,7 @@ jobs:
         group: ${{ fromJson(needs.info.outputs.test_groups) }}
     steps:
       - name: Restore apt cache
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: |
             ${{ env.APT_CACHE_DIR }}
@@ -1459,7 +1455,7 @@ jobs:
           check-latest: true
       - name: Restore full Python ${{ matrix.python-version }} virtual environment
         id: cache-venv
-        uses: actions/cache/restore@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5.0.5
+        uses: actions/cache/restore@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
         with:
           path: venv
           fail-on-cache-miss: true
@@ -1518,14 +1514,14 @@ jobs:
               2>&1 | tee pytest-${PYTHON_VERSION}-${TEST_GROUP}.txt
       - name: Upload pytest output
         if: success() || failure() && steps.pytest-partial.conclusion == 'failure'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: pytest-${{ github.run_number }}-${{ matrix.python-version }}-${{ matrix.group }}
           path: pytest-*.txt
           overwrite: true
       - name: Upload coverage artifact
         if: needs.info.outputs.skip_coverage != 'true'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: coverage-${{ matrix.python-version }}-${{ matrix.group }}
           path: coverage.xml
@@ -1538,7 +1534,7 @@ jobs:
           mv "junit.xml-tmp" "junit.xml"
       - name: Upload test results artifact
         if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: test-results-partial-${{ matrix.python-version }}-${{ matrix.group }}
           path: junit.xml
@@ -1567,7 +1563,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'false'
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }} # zizmor: ignore[secrets-outside-env]
@@ -1595,7 +1591,7 @@ jobs:
         with:
           pattern: test-results-*
       - name: Upload test results to Codecov
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # v6.0.0
+        uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
         with:
           report_type: test_results
           fail_ci_if_error: true

.github/workflows/codeql.yml

@@ -28,11 +28,11 @@ jobs:
           persist-credentials: false
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2
+        uses: github/codeql-action/init@0d579ffd059c29b07949a3cce3983f0780820c98 # v4.32.6
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # v4.35.2
+        uses: github/codeql-action/analyze@0d579ffd059c29b07949a3cce3983f0780820c98 # v4.32.6
         with:
           category: "/language:python"

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

@@ -21,7 +21,7 @@ jobs:
     steps:
       - name: Check if integration label was added and extract details
         id: extract
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         with:
           script: |
             // Debug: Log the event payload
@@ -118,7 +118,7 @@ jobs:
       - name: Fetch similar issues
         id: fetch_similar
         if: steps.extract.outputs.should_continue == 'true'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         env:
           INTEGRATION_LABELS: ${{ steps.extract.outputs.integration_labels }}
           CURRENT_NUMBER: ${{ steps.extract.outputs.current_number }}
@@ -285,7 +285,7 @@ jobs:
       - name: Post duplicate detection results
         id: post_results
         if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         env:
           AI_RESPONSE: ${{ steps.ai_detection.outputs.response }}
           SIMILAR_ISSUES: ${{ steps.fetch_similar.outputs.similar_issues }}

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

@@ -21,7 +21,7 @@ jobs:
     steps:
       - name: Check issue language
         id: detect_language
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         env:
           ISSUE_NUMBER: ${{ github.event.issue.number }}
           ISSUE_TITLE: ${{ github.event.issue.title }}
@@ -95,7 +95,7 @@ jobs:
 
       - name: Process non-English issues
         if: steps.detect_language.outputs.should_continue == 'true'
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         env:
           AI_RESPONSE: ${{ steps.ai_language_detection.outputs.response }}
           ISSUE_NUMBER: ${{ steps.detect_language.outputs.issue_number }}

.github/workflows/restrict-task-creation.yml

@@ -22,7 +22,7 @@ jobs:
       || github.event.issue.type.name == 'Opportunity'
     steps:
       - name: Add no-stale label
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         with:
           script: |
             await github.rest.issues.addLabels({
@@ -42,7 +42,7 @@ jobs:
     if: github.event.issue.type.name == 'Task'
     steps:
       - name: Check if user is authorized
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
         with:
           script: |
             const issueAuthor = context.payload.issue.user.login;

.github/workflows/wheels.yml

@@ -74,7 +74,7 @@ jobs:
           ) > .env_file
 
       - name: Upload env_file
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: env_file
           path: ./.env_file
@@ -82,7 +82,7 @@ jobs:
           overwrite: true
 
       - name: Upload requirements_diff
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: requirements_diff
           path: ./requirements_diff.txt
@@ -94,7 +94,7 @@ jobs:
           python -m script.gen_requirements_all ci
 
       - name: Upload requirements_all_wheels
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
         with:
           name: requirements_all_wheels
           path: ./requirements_all_wheels_*.txt

.gitignore

@@ -142,6 +142,5 @@ pytest_buckets.txt
 
 # AI tooling
 .claude/settings.local.json
-.claude/worktrees/
 .serena/
 

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.15.10
+    rev: v0.15.1
     hooks:
       - id: ruff-check
         args:
@@ -8,7 +8,7 @@ repos:
       - id: ruff-format
         files: ^((homeassistant|pylint|script|tests)/.+)?[^/]+\.(py|pyi)$
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.1
     hooks:
       - id: codespell
         args:
@@ -18,7 +18,7 @@ repos:
         exclude_types: [csv, json, html]
         exclude: ^tests/fixtures/|homeassistant/generated/|tests/components/.*/snapshots/
   - repo: https://github.com/zizmorcore/zizmor-pre-commit
-    rev: v1.24.1
+    rev: v1.23.1
     hooks:
       - id: zizmor
         args:
@@ -36,7 +36,7 @@ repos:
           - --branch=master
           - --branch=rc
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.38.0
+    rev: v1.37.1
     hooks:
       - id: yamllint
   - repo: https://github.com/rbubley/mirrors-prettier
@@ -87,13 +87,6 @@ repos:
         language: script
         types: [text]
         files: ^(homeassistant/.+/manifest\.json|homeassistant/brands/.+\.json|pyproject\.toml|\.pre-commit-config\.yaml|script/gen_requirements_all\.py)$
-      - id: gen_copilot_instructions
-        name: gen_copilot_instructions
-        entry: script/run-in-env.sh python3 -m script.gen_copilot_instructions
-        pass_filenames: false
-        language: script
-        types: [text]
-        files: ^(AGENTS\.md|\.claude/skills/(?!github-pr-reviewer/).+/SKILL\.md|\.github/copilot-instructions\.md|script/gen_copilot_instructions\.py)$
       - id: hassfest
         name: hassfest
         entry: script/run-in-env.sh python3 -m script.hassfest

.python-version

@@ -1 +1 @@
-3.14.3
+3.14.2

.strict-typing

@@ -46,7 +46,6 @@ homeassistant.components.accuweather.*
 homeassistant.components.acer_projector.*
 homeassistant.components.acmeda.*
 homeassistant.components.actiontec.*
-homeassistant.components.actron_air.*
 homeassistant.components.adax.*
 homeassistant.components.adguard.*
 homeassistant.components.aftership.*
@@ -179,7 +178,6 @@ homeassistant.components.dropbox.*
 homeassistant.components.droplet.*
 homeassistant.components.dsmr.*
 homeassistant.components.duckdns.*
-homeassistant.components.duco.*
 homeassistant.components.dunehd.*
 homeassistant.components.duotecno.*
 homeassistant.components.easyenergy.*
@@ -224,7 +222,6 @@ homeassistant.components.fronius.*
 homeassistant.components.frontend.*
 homeassistant.components.fujitsu_fglair.*
 homeassistant.components.fully_kiosk.*
-homeassistant.components.fumis.*
 homeassistant.components.fyta.*
 homeassistant.components.generic_hygrostat.*
 homeassistant.components.generic_thermostat.*
@@ -335,7 +332,6 @@ homeassistant.components.letpot.*
 homeassistant.components.lg_infrared.*
 homeassistant.components.libre_hardware_monitor.*
 homeassistant.components.lidarr.*
-homeassistant.components.liebherr.*
 homeassistant.components.lifx.*
 homeassistant.components.light.*
 homeassistant.components.linkplay.*
@@ -555,7 +551,6 @@ homeassistant.components.tcp.*
 homeassistant.components.technove.*
 homeassistant.components.tedee.*
 homeassistant.components.telegram_bot.*
-homeassistant.components.teleinfo.*
 homeassistant.components.teslemetry.*
 homeassistant.components.text.*
 homeassistant.components.thethingsnetwork.*
@@ -584,7 +579,6 @@ homeassistant.components.trmnl.*
 homeassistant.components.tts.*
 homeassistant.components.twentemilieu.*
 homeassistant.components.unifi.*
-homeassistant.components.unifi_access.*
 homeassistant.components.unifiprotect.*
 homeassistant.components.upcloud.*
 homeassistant.components.update.*
@@ -599,7 +593,6 @@ homeassistant.components.vallox.*
 homeassistant.components.valve.*
 homeassistant.components.velbus.*
 homeassistant.components.velux.*
-homeassistant.components.victron_gx.*
 homeassistant.components.vivotek.*
 homeassistant.components.vlc_telnet.*
 homeassistant.components.vodafone_station.*

AGENTS.md

@@ -2,9 +2,10 @@
 
 This repository contains the core of Home Assistant, a Python 3 based home automation application.
 
-## Git Commit Guidelines
+## Code Review Guidelines
 
-- **Do NOT amend, squash, or rebase commits that have already been pushed to the PR branch after the PR is opened** - Reviewers need to follow the commit history, as well as see what changed since their last review
+**Git commit practices during review:**
+- **Do NOT amend, squash, or rebase commits after review has started** - Reviewers need to see what changed since their last review
 
 ## Development Commands
 
@@ -12,7 +13,7 @@ This repository contains the core of Home Assistant, a Python 3 based home autom
 
 ## Python Syntax Notes
 
-- Python 3.14 explicitly allows `except TypeA, TypeB:` without parentheses. Never flag this as an issue since Home Assistant officially supports Python 3.14.
+- Python 3.14 explicitly allows `except TypeA, TypeB:` without parentheses.
 
 ## Testing
 
@@ -22,6 +23,3 @@ Prefer concrete types (for example, `HomeAssistant`, `MockConfigEntry`, etc.) ov
 ## Good practices
 
 Integrations with Platinum or Gold level in the Integration Quality Scale reflect a high standard of code quality and maintainability. When looking for examples of something, these are good places to start. The level is indicated in the manifest.json of the integration.
-
-When reviewing entity actions, do not suggest extra defensive checks for input fields that are already validated by Home Assistant's service/action schemas and entity selection filters. Suggest additional guards only when data bypasses those validators or is transformed into a less-safe form.
-When validation guarantees a dict key exists, prefer direct key access (`data["key"]`) instead of `.get("key")` so contract violations are surfaced instead of silently masked.

CODEOWNERS

@@ -37,13 +37,6 @@ build.json @home-assistant/supervisor
 # Other code
 /homeassistant/scripts/check_config.py @kellerza
 
-# Agent Configurations
-AGENTS.md @home-assistant/core
-CLAUDE.md @home-assistant/core
-/.agent/ @home-assistant/core
-/.claude/ @home-assistant/core
-/.gemini/ @home-assistant/core
-
 # Integrations
 /homeassistant/components/abode/ @shred86
 /tests/components/abode/ @shred86
@@ -229,8 +222,8 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/binary_sensor/ @home-assistant/core
 /tests/components/binary_sensor/ @home-assistant/core
 /homeassistant/components/bizkaibus/ @UgaitzEtxebarria
-/homeassistant/components/blebox/ @bbx-a @swistakm @bkobus-bbx
-/tests/components/blebox/ @bbx-a @swistakm @bkobus-bbx
+/homeassistant/components/blebox/ @bbx-a @swistakm
+/tests/components/blebox/ @bbx-a @swistakm
 /homeassistant/components/blink/ @fronzbot
 /tests/components/blink/ @fronzbot
 /homeassistant/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
@@ -362,8 +355,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/deluge/ @tkdrob
 /homeassistant/components/demo/ @home-assistant/core
 /tests/components/demo/ @home-assistant/core
-/homeassistant/components/denon_rs232/ @balloob
-/tests/components/denon_rs232/ @balloob
 /homeassistant/components/denonavr/ @ol-iver @starkillerOG
 /tests/components/denonavr/ @ol-iver @starkillerOG
 /homeassistant/components/derivative/ @afaucogney @karwosts
@@ -400,8 +391,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/dnsip/ @gjohansson-ST
 /homeassistant/components/door/ @home-assistant/core
 /tests/components/door/ @home-assistant/core
-/homeassistant/components/doorbell/ @home-assistant/core
-/tests/components/doorbell/ @home-assistant/core
 /homeassistant/components/doorbird/ @oblogic7 @bdraco @flacjacket
 /tests/components/doorbird/ @oblogic7 @bdraco @flacjacket
 /homeassistant/components/dormakaba_dkey/ @emontnemery
@@ -422,8 +411,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/dsmr_reader/ @sorted-bits @glodenox @erwindouna
 /homeassistant/components/duckdns/ @tr4nt0r
 /tests/components/duckdns/ @tr4nt0r
-/homeassistant/components/duco/ @ronaldvdmeer
-/tests/components/duco/ @ronaldvdmeer
 /homeassistant/components/duotecno/ @cereal2nd
 /tests/components/duotecno/ @cereal2nd
 /homeassistant/components/dwd_weather_warnings/ @runningman84 @stephan192
@@ -432,8 +419,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/dynalite/ @ziv1234
 /homeassistant/components/eafm/ @Jc2k
 /tests/components/eafm/ @Jc2k
-/homeassistant/components/earn_e_p1/ @Miggets7
-/tests/components/earn_e_p1/ @Miggets7
 /homeassistant/components/easyenergy/ @klaasnicolaas
 /tests/components/easyenergy/ @klaasnicolaas
 /homeassistant/components/ecoforest/ @pjanuario
@@ -495,8 +480,8 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/environment_canada/ @gwww @michaeldavie
 /tests/components/environment_canada/ @gwww @michaeldavie
 /homeassistant/components/ephember/ @ttroy50 @roberty99
-/homeassistant/components/epic_games_store/ @Quentame
-/tests/components/epic_games_store/ @Quentame
+/homeassistant/components/epic_games_store/ @hacf-fr @Quentame
+/tests/components/epic_games_store/ @hacf-fr @Quentame
 /homeassistant/components/epion/ @lhgravendeel
 /tests/components/epion/ @lhgravendeel
 /homeassistant/components/epson/ @pszafer
@@ -511,8 +496,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/essent/ @jaapp
 /homeassistant/components/eufylife_ble/ @bdr99
 /tests/components/eufylife_ble/ @bdr99
-/homeassistant/components/eurotronic_cometblue/ @rikroe
-/tests/components/eurotronic_cometblue/ @rikroe
 /homeassistant/components/event/ @home-assistant/core
 /tests/components/event/ @home-assistant/core
 /homeassistant/components/evohome/ @zxdavb
@@ -572,8 +555,8 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/fortios/ @kimfrellsen
 /homeassistant/components/foscam/ @Foscam-wangzhengyu
 /tests/components/foscam/ @Foscam-wangzhengyu
-/homeassistant/components/freebox/ @hacf-fr/reviewers @Quentame
-/tests/components/freebox/ @hacf-fr/reviewers @Quentame
+/homeassistant/components/freebox/ @hacf-fr @Quentame
+/tests/components/freebox/ @hacf-fr @Quentame
 /homeassistant/components/freedompro/ @stefano055415
 /tests/components/freedompro/ @stefano055415
 /homeassistant/components/freshr/ @SierraNL
@@ -594,8 +577,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/fujitsu_fglair/ @crevetor
 /homeassistant/components/fully_kiosk/ @cgarwood
 /tests/components/fully_kiosk/ @cgarwood
-/homeassistant/components/fumis/ @frenck
-/tests/components/fumis/ @frenck
 /homeassistant/components/fyta/ @dontinelli
 /tests/components/fyta/ @dontinelli
 /homeassistant/components/garage_door/ @home-assistant/core
@@ -758,12 +739,10 @@ CLAUDE.md @home-assistant/core
 /tests/components/homewizard/ @DCSBL
 /homeassistant/components/honeywell/ @rdfurman @mkmer
 /tests/components/honeywell/ @rdfurman @mkmer
-/homeassistant/components/honeywell_string_lights/ @balloob
-/tests/components/honeywell_string_lights/ @balloob
 /homeassistant/components/hr_energy_qube/ @MattieGit
 /tests/components/hr_energy_qube/ @MattieGit
-/homeassistant/components/html5/ @alexyao2015 @tr4nt0r
-/tests/components/html5/ @alexyao2015 @tr4nt0r
+/homeassistant/components/html5/ @alexyao2015
+/tests/components/html5/ @alexyao2015
 /homeassistant/components/http/ @home-assistant/core
 /tests/components/http/ @home-assistant/core
 /homeassistant/components/huawei_lte/ @scop @fphammerle
@@ -908,8 +887,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/jewish_calendar/ @tsvi
 /homeassistant/components/justnimbus/ @kvanzuijlen
 /tests/components/justnimbus/ @kvanzuijlen
-/homeassistant/components/jvc_projector/ @SteveEasley
-/tests/components/jvc_projector/ @SteveEasley
+/homeassistant/components/jvc_projector/ @SteveEasley @msavazzi
+/tests/components/jvc_projector/ @SteveEasley @msavazzi
 /homeassistant/components/kaiterra/ @Michsior14
 /homeassistant/components/kaleidescape/ @SteveEasley
 /tests/components/kaleidescape/ @SteveEasley
@@ -922,8 +901,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/keyboard_remote/ @bendavid @lanrat
 /homeassistant/components/keymitt_ble/ @spycle
 /tests/components/keymitt_ble/ @spycle
-/homeassistant/components/kiosker/ @Claeysson
-/tests/components/kiosker/ @Claeysson
 /homeassistant/components/kitchen_sink/ @home-assistant/core
 /tests/components/kitchen_sink/ @home-assistant/core
 /homeassistant/components/kmtronic/ @dgomes
@@ -1069,8 +1046,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/met/ @danielhiversen
 /homeassistant/components/met_eireann/ @DylanGore
 /tests/components/met_eireann/ @DylanGore
-/homeassistant/components/meteo_france/ @hacf-fr/reviewers @oncleben31 @Quentame
-/tests/components/meteo_france/ @hacf-fr/reviewers @oncleben31 @Quentame
+/homeassistant/components/meteo_france/ @hacf-fr @oncleben31 @Quentame
+/tests/components/meteo_france/ @hacf-fr @oncleben31 @Quentame
 /homeassistant/components/meteo_lt/ @xE1H
 /tests/components/meteo_lt/ @xE1H
 /homeassistant/components/meteoalarm/ @rolfberkenbosch
@@ -1162,8 +1139,8 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/netatmo/ @cgtobi
 /tests/components/netatmo/ @cgtobi
 /homeassistant/components/netdata/ @fabaff
-/homeassistant/components/netgear/ @Quentame @starkillerOG
-/tests/components/netgear/ @Quentame @starkillerOG
+/homeassistant/components/netgear/ @hacf-fr @Quentame @starkillerOG
+/tests/components/netgear/ @hacf-fr @Quentame @starkillerOG
 /homeassistant/components/netgear_lte/ @tkdrob
 /tests/components/netgear_lte/ @tkdrob
 /homeassistant/components/network/ @home-assistant/core
@@ -1203,8 +1180,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/notify_events/ @matrozov @papajojo
 /homeassistant/components/notion/ @bachya
 /tests/components/notion/ @bachya
-/homeassistant/components/novy_cooker_hood/ @piitaya
-/tests/components/novy_cooker_hood/ @piitaya
 /homeassistant/components/nrgkick/ @andijakl
 /tests/components/nrgkick/ @andijakl
 /homeassistant/components/nsw_fuel_station/ @nickw444
@@ -1257,10 +1232,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/onvif/ @jterrace
 /homeassistant/components/open_meteo/ @frenck
 /tests/components/open_meteo/ @frenck
-/homeassistant/components/open_router/ @joostlek @ab3lson
-/tests/components/open_router/ @joostlek @ab3lson
-/homeassistant/components/openai_conversation/ @Shulyaka
-/tests/components/openai_conversation/ @Shulyaka
+/homeassistant/components/open_router/ @joostlek
+/tests/components/open_router/ @joostlek
 /homeassistant/components/opendisplay/ @g4bri3lDev
 /tests/components/opendisplay/ @g4bri3lDev
 /homeassistant/components/openerz/ @misialq
@@ -1283,8 +1256,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/openuv/ @bachya
 /homeassistant/components/openweathermap/ @fabaff @freekode @nzapponi @wittypluck
 /tests/components/openweathermap/ @fabaff @freekode @nzapponi @wittypluck
-/homeassistant/components/opnsense/ @HarlemSquirrel @Snuffy2
-/tests/components/opnsense/ @HarlemSquirrel @Snuffy2
+/homeassistant/components/opnsense/ @mtreinish
+/tests/components/opnsense/ @mtreinish
 /homeassistant/components/opower/ @tronikos
 /tests/components/opower/ @tronikos
 /homeassistant/components/oralb/ @bdraco @Lash-L
@@ -1328,8 +1301,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/pi_hole/ @shenxn
 /homeassistant/components/picnic/ @corneyl @codesalatdev
 /tests/components/picnic/ @corneyl @codesalatdev
-/homeassistant/components/picotts/ @rooggiieerr
-/tests/components/picotts/ @rooggiieerr
 /homeassistant/components/ping/ @jpbede
 /tests/components/ping/ @jpbede
 /homeassistant/components/plaato/ @JohNan
@@ -1419,8 +1390,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/radarr/ @tkdrob
 /homeassistant/components/radio_browser/ @frenck
 /tests/components/radio_browser/ @frenck
-/homeassistant/components/radio_frequency/ @home-assistant/core
-/tests/components/radio_frequency/ @home-assistant/core
 /homeassistant/components/radiotherm/ @vinnyfuria
 /tests/components/radiotherm/ @vinnyfuria
 /homeassistant/components/rainbird/ @konikvranik @allenporter
@@ -1712,8 +1681,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/syncthing/ @zhulik
 /homeassistant/components/syncthru/ @nielstron
 /tests/components/syncthru/ @nielstron
-/homeassistant/components/synology_dsm/ @Quentame @mib1185
-/tests/components/synology_dsm/ @Quentame @mib1185
+/homeassistant/components/synology_dsm/ @hacf-fr @Quentame @mib1185
+/tests/components/synology_dsm/ @hacf-fr @Quentame @mib1185
 /homeassistant/components/synology_srm/ @aerialls
 /homeassistant/components/system_bridge/ @timmo001
 /tests/components/system_bridge/ @timmo001
@@ -1744,8 +1713,6 @@ CLAUDE.md @home-assistant/core
 /tests/components/tedee/ @patrickhilker @zweckj
 /homeassistant/components/telegram_bot/ @hanwg
 /tests/components/telegram_bot/ @hanwg
-/homeassistant/components/teleinfo/ @esciara
-/tests/components/teleinfo/ @esciara
 /homeassistant/components/tellduslive/ @fredrike
 /tests/components/tellduslive/ @fredrike
 /homeassistant/components/teltonika/ @karlbeecken
@@ -1848,8 +1815,6 @@ CLAUDE.md @home-assistant/core
 /homeassistant/components/unifi_access/ @imhotep @RaHehl
 /tests/components/unifi_access/ @imhotep @RaHehl
 /homeassistant/components/unifi_direct/ @tofuSCHNITZEL
-/homeassistant/components/unifi_discovery/ @RaHehl
-/tests/components/unifi_discovery/ @RaHehl
 /homeassistant/components/unifiled/ @florisvdk
 /homeassistant/components/unifiprotect/ @RaHehl
 /tests/components/unifiprotect/ @RaHehl
@@ -1897,12 +1862,10 @@ CLAUDE.md @home-assistant/core
 /tests/components/version/ @ludeeus
 /homeassistant/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
 /tests/components/vesync/ @markperdue @webdjoe @thegardenmonkey @cdnninja @iprak @sapuseven
-/homeassistant/components/vicare/ @CFenner @lackas
-/tests/components/vicare/ @CFenner @lackas
+/homeassistant/components/vicare/ @CFenner
+/tests/components/vicare/ @CFenner
 /homeassistant/components/victron_ble/ @rajlaud
 /tests/components/victron_ble/ @rajlaud
-/homeassistant/components/victron_gx/ @tomer-w
-/tests/components/victron_gx/ @tomer-w
 /homeassistant/components/victron_remote_monitoring/ @AndyTempel
 /tests/components/victron_remote_monitoring/ @AndyTempel
 /homeassistant/components/vilfo/ @ManneW
@@ -1989,8 +1952,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/wled/ @frenck @mik-laj
 /homeassistant/components/wmspro/ @mback2k
 /tests/components/wmspro/ @mback2k
-/homeassistant/components/wolflink/ @adamkrol93 @EnjoyingM
-/tests/components/wolflink/ @adamkrol93 @EnjoyingM
+/homeassistant/components/wolflink/ @adamkrol93 @mtielen
+/tests/components/wolflink/ @adamkrol93 @mtielen
 /homeassistant/components/workday/ @fabaff @gjohansson-ST
 /tests/components/workday/ @fabaff @gjohansson-ST
 /homeassistant/components/worldclock/ @fabaff
@@ -2001,8 +1964,8 @@ CLAUDE.md @home-assistant/core
 /tests/components/wsdot/ @ucodery
 /homeassistant/components/wyoming/ @synesthesiam
 /tests/components/wyoming/ @synesthesiam
-/homeassistant/components/xbox/ @tr4nt0r
-/tests/components/xbox/ @tr4nt0r
+/homeassistant/components/xbox/ @hunterjm @tr4nt0r
+/tests/components/xbox/ @hunterjm @tr4nt0r
 /homeassistant/components/xiaomi_aqara/ @danielhiversen @syssi
 /tests/components/xiaomi_aqara/ @danielhiversen @syssi
 /homeassistant/components/xiaomi_ble/ @Jc2k @Ernst79

Dockerfile

@@ -1,4 +1,3 @@
-# syntax=docker/dockerfile@sha256:2780b5c3bab67f1f76c781860de469442999ed1a0d7992a5efdf2cffc0e3d769
 # Automatically generated by hassfest.
 #
 # To update, run python3 -m script.hassfest -p docker
@@ -20,22 +19,25 @@ ENV \
     UV_SYSTEM_PYTHON=true \
     UV_NO_CACHE=true
 
-WORKDIR /usr/src
-
 # Home Assistant S6-Overlay
 COPY rootfs /
 
 # Add go2rtc binary
 COPY --from=ghcr.io/alexxit/go2rtc@sha256:675c318b23c06fd862a61d262240c9a63436b4050d177ffc68a32710d9e05bae /usr/local/bin/go2rtc /bin/go2rtc
 
-## Setup Home Assistant Core dependencies
-COPY --parents requirements.txt homeassistant/package_constraints.txt homeassistant/
 RUN \
     # Verify go2rtc can be executed
     go2rtc --version \
-    # Install uv at the version pinned in the requirements file
-    && pip3 install --no-cache-dir "uv==$(awk -F'==' '/^uv==/{print $2}' homeassistant/requirements.txt)" \
-    && uv pip install \
+    # Install uv
+    && pip3 install uv==0.11.1
+
+WORKDIR /usr/src
+
+## Setup Home Assistant Core dependencies
+COPY requirements.txt homeassistant/
+COPY homeassistant/package_constraints.txt homeassistant/homeassistant/
+RUN \
+    uv pip install \
         --no-build \
         -r homeassistant/requirements.txt
 
@@ -49,7 +51,7 @@ RUN \
         -r homeassistant/requirements_all.txt
 
 ## Setup Home Assistant Core
-COPY --parents LICENSE* README* homeassistant/ pyproject.toml homeassistant/
+COPY . homeassistant/
 RUN \
     uv pip install \
         -e ./homeassistant \

Dockerfile.dev

@@ -1,4 +1,3 @@
-# syntax=docker/dockerfile@sha256:2780b5c3bab67f1f76c781860de469442999ed1a0d7992a5efdf2cffc0e3d769
 FROM mcr.microsoft.com/vscode/devcontainers/base:debian
 
 SHELL ["/bin/bash", "-o", "pipefail", "-c"]

homeassistant/auth/jwt_wrapper.py

@@ -7,31 +7,23 @@ to speed up the process.
 
 from __future__ import annotations
 
-from collections.abc import Container, Iterable, Sequence
 from datetime import timedelta
-from functools import lru_cache
-from typing import Any, override
+from functools import lru_cache, partial
+from typing import Any
 
-from jwt import DecodeError, PyJWK, PyJWS, PyJWT
-from jwt.algorithms import AllowedPublicKeys
-from jwt.types import Options
+from jwt import DecodeError, PyJWS, PyJWT
 
 from homeassistant.util.json import json_loads
 
 JWT_TOKEN_CACHE_SIZE = 16
 MAX_TOKEN_SIZE = 8192
 
-_NO_VERIFY_OPTIONS = Options(
-    verify_signature=False,
-    verify_exp=False,
-    verify_nbf=False,
-    verify_iat=False,
-    verify_aud=False,
-    verify_iss=False,
-    verify_sub=False,
-    verify_jti=False,
-    require=[],
-)
+_VERIFY_KEYS = ("signature", "exp", "nbf", "iat", "aud", "iss", "sub", "jti")
+
+_VERIFY_OPTIONS: dict[str, Any] = {f"verify_{key}": True for key in _VERIFY_KEYS} | {
+    "require": []
+}
+_NO_VERIFY_OPTIONS = {f"verify_{key}": False for key in _VERIFY_KEYS}
 
 
 class _PyJWSWithLoadCache(PyJWS):
@@ -46,6 +38,9 @@ class _PyJWSWithLoadCache(PyJWS):
         return super()._load(jwt)
 
 
+_jws = _PyJWSWithLoadCache()
+
+
 @lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)
 def _decode_payload(json_payload: str) -> dict[str, Any]:
     """Decode the payload from a JWS dictionary."""
@@ -61,12 +56,21 @@ def _decode_payload(json_payload: str) -> dict[str, Any]:
 class _PyJWTWithVerify(PyJWT):
     """PyJWT with a fast decode implementation."""
 
-    def __init__(self) -> None:
-        """Initialize the PyJWT instance."""
-        # We require exp and iat claims to be present
-        super().__init__(Options(require=["exp", "iat"]))
-        # Override the _jws instance with our cached version
-        self._jws = _PyJWSWithLoadCache()
+    def decode_payload(
+        self, jwt: str, key: str, options: dict[str, Any], algorithms: list[str]
+    ) -> dict[str, Any]:
+        """Decode a JWT's payload."""
+        if len(jwt) > MAX_TOKEN_SIZE:
+            # Avoid caching impossible tokens
+            raise DecodeError("Token too large")
+        return _decode_payload(
+            _jws.decode_complete(
+                jwt=jwt,
+                key=key,
+                algorithms=algorithms,
+                options=options,
+            )["payload"]
+        )
 
     def verify_and_decode(
         self,
@@ -75,70 +79,37 @@ class _PyJWTWithVerify(PyJWT):
         algorithms: list[str],
         issuer: str | None = None,
         leeway: float | timedelta = 0,
-        options: Options | None = None,
+        options: dict[str, Any] | None = None,
     ) -> dict[str, Any]:
         """Verify a JWT's signature and claims."""
-        return self.decode(
+        merged_options = {**_VERIFY_OPTIONS, **(options or {})}
+        payload = self.decode_payload(
             jwt=jwt,
             key=key,
+            options=merged_options,
             algorithms=algorithms,
+        )
+        # These should never be missing since we verify them
+        # but this is an additional safeguard to make sure
+        # nothing slips through.
+        assert "exp" in payload, "exp claim is required"
+        assert "iat" in payload, "iat claim is required"
+        self._validate_claims(
+            payload=payload,
+            options=merged_options,
             issuer=issuer,
             leeway=leeway,
-            options=options,
         )
-
-    @override
-    def decode(
-        self,
-        jwt: str | bytes,
-        key: AllowedPublicKeys | PyJWK | str | bytes = "",
-        algorithms: Sequence[str] | None = None,
-        options: Options | None = None,
-        verify: bool | None = None,
-        detached_payload: bytes | None = None,
-        audience: str | Iterable[str] | None = None,
-        subject: str | None = None,
-        issuer: str | Container[str] | None = None,
-        leeway: float | timedelta = 0,
-        **kwargs: Any,
-    ) -> dict[str, Any]:
-        """Decode a JWT, verifying the signature and claims."""
-        if len(jwt) > MAX_TOKEN_SIZE:
-            # Avoid caching impossible tokens
-            raise DecodeError("Token too large")
-        return super().decode(
-            jwt=jwt,
-            key=key,
-            algorithms=algorithms,
-            options=options,
-            verify=verify,
-            detached_payload=detached_payload,
-            audience=audience,
-            subject=subject,
-            issuer=issuer,
-            leeway=leeway,
-            **kwargs,
-        )
-
-    @override
-    def _decode_payload(self, decoded: dict[str, Any]) -> dict[str, Any]:
-        return _decode_payload(decoded["payload"])
+        return payload
 
 
 _jwt = _PyJWTWithVerify()
 verify_and_decode = _jwt.verify_and_decode
-
-
-@lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)
-def unverified_hs256_token_decode(jwt: str) -> dict[str, Any]:
-    """Decode a JWT without verifying the signature."""
-    return _jwt.decode(
-        jwt=jwt,
-        key="",
-        algorithms=["HS256"],
-        options=_NO_VERIFY_OPTIONS,
+unverified_hs256_token_decode = lru_cache(maxsize=JWT_TOKEN_CACHE_SIZE)(
+    partial(
+        _jwt.decode_payload, key="", algorithms=["HS256"], options=_NO_VERIFY_OPTIONS
     )
-
+)
 
 __all__ = [
     "unverified_hs256_token_decode",

homeassistant/bootstrap.py

@@ -238,9 +238,7 @@ DEFAULT_INTEGRATIONS = {
     "timer",
     #
     # Base platforms:
-    # Note: Calendar and todo are not included to prevent them from registering
-    # their frontend panels when there are no calendar or todo integrations.
-    *(BASE_PLATFORMS - {"calendar", "todo"}),
+    *BASE_PLATFORMS,
     #
     # Integrations providing triggers and conditions for base platforms:
     "air_quality",

homeassistant/brands/bega.json

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

homeassistant/brands/denon.json

@@ -1,5 +1,5 @@
 {
   "domain": "denon",
   "name": "Denon",
-  "integrations": ["denon", "denonavr", "denon_rs232", "heos"]
+  "integrations": ["denon", "denonavr", "heos"]
 }

homeassistant/brands/honeywell.json

@@ -1,5 +1,5 @@
 {
   "domain": "honeywell",
   "name": "Honeywell",
-  "integrations": ["lyric", "evohome", "honeywell", "honeywell_string_lights"]
+  "integrations": ["lyric", "evohome", "honeywell"]
 }

homeassistant/brands/ubiquiti.json

@@ -6,7 +6,6 @@
     "unifi",
     "unifi_access",
     "unifi_direct",
-    "unifi_discovery",
     "unifiled",
     "unifiprotect"
   ]

homeassistant/brands/victron.json

@@ -1,5 +1,5 @@
 {
   "domain": "victron",
   "name": "Victron",
-  "integrations": ["victron_gx", "victron_ble", "victron_remote_monitoring"]
+  "integrations": ["victron_ble", "victron_remote_monitoring"]
 }

homeassistant/components/abode/__init__.py

@@ -30,7 +30,7 @@ from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_POLLING, DOMAIN, LOGGER
+from .const import CONF_POLLING, DOMAIN, DOMAIN_DATA, LOGGER
 from .services import async_setup_services
 
 ATTR_DEVICE_NAME = "device_name"
@@ -67,16 +67,13 @@ class AbodeSystem:
     logout_listener: CALLBACK_TYPE | None = None
 
 
-type AbodeConfigEntry = ConfigEntry[AbodeSystem]
-
-
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Abode component."""
     async_setup_services(hass)
     return True
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: AbodeConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Abode integration from a config entry."""
     username = entry.data[CONF_USERNAME]
     password = entry.data[CONF_PASSWORD]
@@ -102,54 +99,50 @@ async def async_setup_entry(hass: HomeAssistant, entry: AbodeConfigEntry) -> boo
     except (AbodeException, ConnectTimeout, HTTPError) as ex:
         raise ConfigEntryNotReady(f"Unable to connect to Abode: {ex}") from ex
 
-    entry.runtime_data = AbodeSystem(abode, polling)
+    hass.data[DOMAIN_DATA] = AbodeSystem(abode, polling)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-    await setup_hass_events(hass, entry)
-    await hass.async_add_executor_job(setup_abode_events, hass, entry)
+    await setup_hass_events(hass)
+    await hass.async_add_executor_job(setup_abode_events, hass)
 
     return True
 
 
-def _shutdown_client(abode: Abode) -> None:
-    """Shutdown client."""
-    abode.events.stop()
-    abode.logout()
-
-
-async def async_unload_entry(hass: HomeAssistant, entry: AbodeConfigEntry) -> bool:
+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(_shutdown_client, entry.runtime_data.abode)
+    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)
 
-    if logout_listener := entry.runtime_data.logout_listener:
+    if logout_listener := hass.data[DOMAIN_DATA].logout_listener:
         logout_listener()
+    hass.data.pop(DOMAIN_DATA)
 
     return unload_ok
 
 
-async def setup_hass_events(hass: HomeAssistant, entry: AbodeConfigEntry) -> None:
+async def setup_hass_events(hass: HomeAssistant) -> None:
     """Home Assistant start and stop callbacks."""
 
     def logout(event: Event) -> None:
         """Logout of Abode."""
-        if not entry.runtime_data.polling:
-            entry.runtime_data.abode.events.stop()
+        if not hass.data[DOMAIN_DATA].polling:
+            hass.data[DOMAIN_DATA].abode.events.stop()
 
-        entry.runtime_data.abode.logout()
+        hass.data[DOMAIN_DATA].abode.logout()
         LOGGER.info("Logged out of Abode")
 
-    if not entry.runtime_data.polling:
-        await hass.async_add_executor_job(entry.runtime_data.abode.events.start)
+    if not hass.data[DOMAIN_DATA].polling:
+        await hass.async_add_executor_job(hass.data[DOMAIN_DATA].abode.events.start)
 
-    entry.runtime_data.logout_listener = hass.bus.async_listen_once(
+    hass.data[DOMAIN_DATA].logout_listener = hass.bus.async_listen_once(
         EVENT_HOMEASSISTANT_STOP, logout
     )
 
 
-def setup_abode_events(hass: HomeAssistant, entry: AbodeConfigEntry) -> None:
+def setup_abode_events(hass: HomeAssistant) -> None:
     """Event callbacks."""
 
     def event_callback(event: str, event_json: dict[str, str]) -> None:
@@ -186,6 +179,6 @@ def setup_abode_events(hass: HomeAssistant, entry: AbodeConfigEntry) -> None:
     ]
 
     for event in events:
-        entry.runtime_data.abode.events.add_event_callback(
+        hass.data[DOMAIN_DATA].abode.events.add_event_callback(
             event, partial(event_callback, event)
         )

homeassistant/components/abode/alarm_control_panel.py

@@ -9,20 +9,21 @@ from homeassistant.components.alarm_control_panel import (
     AlarmControlPanelEntityFeature,
     AlarmControlPanelState,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeConfigEntry
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: AbodeConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode alarm control panel device."""
-    data = entry.runtime_data
+    data = hass.data[DOMAIN_DATA]
     async_add_entities(
         [AbodeAlarm(data, await hass.async_add_executor_job(data.abode.get_alarm))]
     )

homeassistant/components/abode/binary_sensor.py

@@ -10,21 +10,22 @@ from homeassistant.components.binary_sensor import (
     BinarySensorDeviceClass,
     BinarySensorEntity,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.enum import try_parse_enum
 
-from . import AbodeConfigEntry
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: AbodeConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode binary sensor devices."""
-    data = entry.runtime_data
+    data = hass.data[DOMAIN_DATA]
 
     device_types = [
         "connectivity",

homeassistant/components/abode/camera.py

@@ -12,13 +12,14 @@ import requests
 from requests.models import Response
 
 from homeassistant.components.camera import Camera
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import Event, HomeAssistant
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util import Throttle
 
-from . import AbodeConfigEntry, AbodeSystem
-from .const import LOGGER
+from . import AbodeSystem
+from .const import DOMAIN_DATA, LOGGER
 from .entity import AbodeDevice
 
 MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=90)
@@ -26,11 +27,11 @@ MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=90)
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: AbodeConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode camera devices."""
-    data = entry.runtime_data
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeCamera(data, device, timeline.CAPTURE_IMAGE)

homeassistant/components/abode/const.py

@@ -3,10 +3,17 @@
 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

@@ -5,20 +5,21 @@ from typing import Any
 from jaraco.abode.devices.cover import Cover
 
 from homeassistant.components.cover import CoverEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeConfigEntry
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: AbodeConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode cover devices."""
-    data = entry.runtime_data
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeCover(data, device)

homeassistant/components/abode/entity.py

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

homeassistant/components/abode/light.py

@@ -16,20 +16,21 @@ from homeassistant.components.light import (
     ColorMode,
     LightEntity,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeConfigEntry
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: AbodeConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode light devices."""
-    data = entry.runtime_data
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeLight(data, device)

homeassistant/components/abode/lock.py

@@ -5,20 +5,21 @@ from typing import Any
 from jaraco.abode.devices.lock import Lock
 
 from homeassistant.components.lock import LockEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeConfigEntry
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: AbodeConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode lock devices."""
-    data = entry.runtime_data
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeLock(data, device)

homeassistant/components/abode/sensor.py

@@ -14,11 +14,13 @@ from homeassistant.components.sensor import (
     SensorEntityDescription,
     SensorStateClass,
 )
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import LIGHT_LUX, PERCENTAGE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeConfigEntry, AbodeSystem
+from . import AbodeSystem
+from .const import DOMAIN_DATA
 from .entity import AbodeDevice
 
 ABODE_TEMPERATURE_UNIT_HA_UNIT = {
@@ -64,11 +66,11 @@ SENSOR_TYPES: tuple[AbodeSensorDescription, ...] = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: AbodeConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode sensor devices."""
-    data = entry.runtime_data
+    data = hass.data[DOMAIN_DATA]
 
     async_add_entities(
         AbodeSensor(data, device, description)

homeassistant/components/abode/services.py

@@ -2,21 +2,15 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
-
 from jaraco.abode.exceptions import Exception as AbodeException
 import voluptuous as vol
 
 from homeassistant.const import ATTR_ENTITY_ID
 from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import dispatcher_send
 
-from .const import DOMAIN, LOGGER
-
-if TYPE_CHECKING:
-    from . import AbodeConfigEntry, AbodeSystem
+from .const import DOMAIN, DOMAIN_DATA, LOGGER
 
 ATTR_SETTING = "setting"
 ATTR_VALUE = "value"
@@ -31,21 +25,13 @@ CAPTURE_IMAGE_SCHEMA = vol.Schema({ATTR_ENTITY_ID: cv.entity_ids})
 AUTOMATION_SCHEMA = vol.Schema({ATTR_ENTITY_ID: cv.entity_ids})
 
 
-def _get_abode_system(hass: HomeAssistant) -> AbodeSystem:
-    """Return the Abode system for the loaded config entry."""
-    entries: list[AbodeConfigEntry] = hass.config_entries.async_loaded_entries(DOMAIN)
-    if not entries:
-        raise ServiceValidationError("Abode integration is not loaded")
-    return entries[0].runtime_data
-
-
 def _change_setting(call: ServiceCall) -> None:
     """Change an Abode system setting."""
     setting = call.data[ATTR_SETTING]
     value = call.data[ATTR_VALUE]
 
     try:
-        _get_abode_system(call.hass).abode.set_setting(setting, value)
+        call.hass.data[DOMAIN_DATA].abode.set_setting(setting, value)
     except AbodeException as ex:
         LOGGER.warning(ex)
 
@@ -56,7 +42,7 @@ def _capture_image(call: ServiceCall) -> None:
 
     target_entities = [
         entity_id
-        for entity_id in _get_abode_system(call.hass).entity_ids
+        for entity_id in call.hass.data[DOMAIN_DATA].entity_ids
         if entity_id in entity_ids
     ]
 
@@ -71,7 +57,7 @@ def _trigger_automation(call: ServiceCall) -> None:
 
     target_entities = [
         entity_id
-        for entity_id in _get_abode_system(call.hass).entity_ids
+        for entity_id in call.hass.data[DOMAIN_DATA].entity_ids
         if entity_id in entity_ids
     ]
 

homeassistant/components/abode/switch.py

@@ -7,11 +7,12 @@ from typing import Any, cast
 from jaraco.abode.devices.switch import Switch
 
 from homeassistant.components.switch import SwitchEntity
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import AbodeConfigEntry
+from .const import DOMAIN_DATA
 from .entity import AbodeAutomation, AbodeDevice
 
 DEVICE_TYPES = ["switch", "valve"]
@@ -19,11 +20,11 @@ DEVICE_TYPES = ["switch", "valve"]
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    entry: AbodeConfigEntry,
+    entry: ConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Abode switch devices."""
-    data = entry.runtime_data
+    data = hass.data[DOMAIN_DATA]
 
     entities: list[SwitchEntity] = [
         AbodeSwitch(data, device)

homeassistant/components/accuweather/config_flow.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from asyncio import timeout
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 from accuweather import AccuWeather, ApiError, InvalidApiKeyError, RequestsExceededError
 from aiohttp import ClientError
@@ -12,7 +12,7 @@ from aiohttp.client_exceptions import ClientConnectorError
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE
+from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE, CONF_NAME
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
@@ -55,11 +55,8 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
                 )
                 self._abort_if_unique_id_configured()
 
-                if TYPE_CHECKING:
-                    assert accuweather.location_name is not None
-
                 return self.async_create_entry(
-                    title=accuweather.location_name, data=user_input
+                    title=user_input[CONF_NAME], data=user_input
                 )
 
         return self.async_show_form(
@@ -73,6 +70,9 @@ class AccuWeatherFlowHandler(ConfigFlow, domain=DOMAIN):
                     vol.Optional(
                         CONF_LONGITUDE, default=self.hass.config.longitude
                     ): cv.longitude,
+                    vol.Optional(
+                        CONF_NAME, default=self.hass.config.location_name
+                    ): str,
                 }
             ),
             errors=errors,

homeassistant/components/accuweather/coordinator.py

@@ -64,7 +64,7 @@ class AccuWeatherObservationDataUpdateCoordinator(
         """Initialize."""
         self.accuweather = accuweather
         self.location_key = accuweather.location_key
-        name = config_entry.data.get(CONF_NAME) or config_entry.title
+        name = config_entry.data[CONF_NAME]
 
         if TYPE_CHECKING:
             assert self.location_key is not None
@@ -122,7 +122,7 @@ class AccuWeatherForecastDataUpdateCoordinator(
         self.accuweather = accuweather
         self.location_key = accuweather.location_key
         self._fetch_method = fetch_method
-        name = config_entry.data.get(CONF_NAME) or config_entry.title
+        name = config_entry.data[CONF_NAME]
 
         if TYPE_CHECKING:
             assert self.location_key is not None

homeassistant/components/accuweather/strings.json

@@ -25,7 +25,8 @@
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]",
           "latitude": "[%key:common::config_flow::data::latitude%]",
-          "longitude": "[%key:common::config_flow::data::longitude%]"
+          "longitude": "[%key:common::config_flow::data::longitude%]",
+          "name": "[%key:common::config_flow::data::name%]"
         },
         "data_description": {
           "api_key": "API key generated in the AccuWeather APIs portal."

homeassistant/components/acer_projector/const.py

@@ -6,11 +6,10 @@ from typing import Final
 
 from homeassistant.const import STATE_OFF, STATE_ON
 
-CONF_READ_TIMEOUT: Final = "timeout"
 CONF_WRITE_TIMEOUT: Final = "write_timeout"
 
 DEFAULT_NAME: Final = "Acer Projector"
-DEFAULT_READ_TIMEOUT: Final = 1
+DEFAULT_TIMEOUT: Final = 1
 DEFAULT_WRITE_TIMEOUT: Final = 1
 
 ECO_MODE: Final = "ECO Mode"

homeassistant/components/acer_projector/manifest.json

@@ -5,5 +5,5 @@
   "documentation": "https://www.home-assistant.io/integrations/acer_projector",
   "iot_class": "local_polling",
   "quality_scale": "legacy",
-  "requirements": ["serialx==1.4.1"]
+  "requirements": ["pyserial==3.5"]
 }

homeassistant/components/acer_projector/switch.py

@@ -6,7 +6,7 @@ import logging
 import re
 from typing import Any
 
-from serialx import Serial, SerialException
+import serial
 import voluptuous as vol
 
 from homeassistant.components.switch import (
@@ -16,22 +16,21 @@ from homeassistant.components.switch import (
 from homeassistant.const import (
     CONF_FILENAME,
     CONF_NAME,
+    CONF_TIMEOUT,
     STATE_OFF,
     STATE_ON,
     STATE_UNKNOWN,
 )
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .const import (
     CMD_DICT,
-    CONF_READ_TIMEOUT,
     CONF_WRITE_TIMEOUT,
     DEFAULT_NAME,
-    DEFAULT_READ_TIMEOUT,
+    DEFAULT_TIMEOUT,
     DEFAULT_WRITE_TIMEOUT,
     ECO_MODE,
     ICON,
@@ -46,7 +45,7 @@ PLATFORM_SCHEMA = SWITCH_PLATFORM_SCHEMA.extend(
     {
         vol.Required(CONF_FILENAME): cv.isdevice,
         vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
-        vol.Optional(CONF_READ_TIMEOUT, default=DEFAULT_READ_TIMEOUT): cv.positive_int,
+        vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
         vol.Optional(
             CONF_WRITE_TIMEOUT, default=DEFAULT_WRITE_TIMEOUT
         ): cv.positive_int,
@@ -63,10 +62,10 @@ def setup_platform(
     """Connect with serial port and return Acer Projector."""
     serial_port = config[CONF_FILENAME]
     name = config[CONF_NAME]
-    read_timeout = config[CONF_READ_TIMEOUT]
+    timeout = config[CONF_TIMEOUT]
     write_timeout = config[CONF_WRITE_TIMEOUT]
 
-    add_entities([AcerSwitch(serial_port, name, read_timeout, write_timeout)], True)
+    add_entities([AcerSwitch(serial_port, name, timeout, write_timeout)], True)
 
 
 class AcerSwitch(SwitchEntity):
@@ -78,14 +77,14 @@ class AcerSwitch(SwitchEntity):
         self,
         serial_port: str,
         name: str,
-        read_timeout: int,
+        timeout: int,
         write_timeout: int,
     ) -> None:
         """Init of the Acer projector."""
+        self.serial = serial.Serial(
+            port=serial_port, timeout=timeout, write_timeout=write_timeout
+        )
         self._serial_port = serial_port
-        self._read_timeout = read_timeout
-        self._write_timeout = write_timeout
-
         self._attr_name = name
         self._attributes = {
             LAMP_HOURS: STATE_UNKNOWN,
@@ -95,26 +94,22 @@ class AcerSwitch(SwitchEntity):
 
     def _write_read(self, msg: str) -> str:
         """Write to the projector and read the return."""
-
+        ret = ""
         # Sometimes the projector won't answer for no reason or the projector
         # was disconnected during runtime.
         # This way the projector can be reconnected and will still work
         try:
-            with Serial.from_url(
-                self._serial_port,
-                read_timeout=self._read_timeout,
-                write_timeout=self._write_timeout,
-            ) as serial:
-                serial.write(msg.encode("utf-8"))
-
-                # Size is an experience value there is no real limit.
-                # AFAIK there is no limit and no end character so we will usually
-                # need to wait for timeout
-                return serial.read_until(size=20).decode("utf-8")
-        except (OSError, SerialException, TimeoutError) as exc:
-            raise HomeAssistantError(
-                f"Problem communicating with {self._serial_port}"
-            ) from exc
+            if not self.serial.is_open:
+                self.serial.open()
+            self.serial.write(msg.encode("utf-8"))
+            # Size is an experience value there is no real limit.
+            # AFAIK there is no limit and no end character so we will usually
+            # need to wait for timeout
+            ret = self.serial.read_until(size=20).decode("utf-8")
+        except serial.SerialException:
+            _LOGGER.error("Problem communicating with %s", self._serial_port)
+        self.serial.close()
+        return ret
 
     def _write_read_format(self, msg: str) -> str:
         """Write msg, obtain answer and format output."""

homeassistant/components/actiontec/__init__.py

@@ -1 +1 @@
-"""The Actiontec integration."""
+"""The actiontec component."""

homeassistant/components/actron_air/__init__.py

@@ -1,7 +1,11 @@
 """The Actron Air integration."""
 
-from actron_neo_api import ActronAirAPI, ActronAirAPIError, ActronAirAuthError
-from actron_neo_api.models.system import ActronAirSystemInfo
+from actron_neo_api import (
+    ActronAirACSystem,
+    ActronAirAPI,
+    ActronAirAPIError,
+    ActronAirAuthError,
+)
 
 from homeassistant.const import CONF_API_TOKEN, Platform
 from homeassistant.core import HomeAssistant
@@ -21,7 +25,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) ->
     """Set up Actron Air integration from a config entry."""
 
     api = ActronAirAPI(refresh_token=entry.data[CONF_API_TOKEN])
-    systems: list[ActronAirSystemInfo] = []
+    systems: list[ActronAirACSystem] = []
 
     try:
         systems = await api.get_ac_systems()
@@ -32,17 +36,14 @@ async def async_setup_entry(hass: HomeAssistant, entry: ActronAirConfigEntry) ->
             translation_key="auth_error",
         ) from err
     except ActronAirAPIError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="setup_connection_error",
-        ) from err
+        raise ConfigEntryNotReady from err
 
     system_coordinators: dict[str, ActronAirSystemCoordinator] = {}
     for system in systems:
         coordinator = ActronAirSystemCoordinator(hass, entry, api, system)
-        _LOGGER.debug("Setting up coordinator for system: %s", system.serial)
+        _LOGGER.debug("Setting up coordinator for system: %s", system["serial"])
         await coordinator.async_config_entry_first_refresh()
-        system_coordinators[system.serial] = coordinator
+        system_coordinators[system["serial"]] = coordinator
 
     entry.runtime_data = ActronAirRuntimeData(
         api=api,

homeassistant/components/actron_air/climate.py

@@ -15,12 +15,10 @@ from homeassistant.components.climate import (
 )
 from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import DOMAIN
 from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-from .entity import ActronAirAcEntity, ActronAirZoneEntity, actron_air_command
+from .entity import ActronAirAcEntity, ActronAirZoneEntity, handle_actron_api_errors
 
 PARALLEL_UPDATES = 0
 
@@ -38,7 +36,6 @@ HVAC_MODE_MAPPING_ACTRONAIR_TO_HA = {
     "HEAT": HVACMode.HEAT,
     "FAN": HVACMode.FAN_ONLY,
     "AUTO": HVACMode.AUTO,
-    "DRY": HVACMode.DRY,
     "OFF": HVACMode.OFF,
 }
 HVAC_MODE_MAPPING_HA_TO_ACTRONAIR = {
@@ -80,6 +77,7 @@ class ActronAirClimateEntity(ClimateEntity):
     )
     _attr_name = None
     _attr_fan_modes = list(FAN_MODE_MAPPING_ACTRONAIR_TO_HA.values())
+    _attr_hvac_modes = list(HVAC_MODE_MAPPING_ACTRONAIR_TO_HA.values())
 
 
 class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
@@ -93,17 +91,6 @@ class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
         super().__init__(coordinator)
         self._attr_unique_id = self._serial_number
 
-    @property
-    def hvac_modes(self) -> list[HVACMode]:
-        """Return the list of supported HVAC modes."""
-        modes = [
-            HVAC_MODE_MAPPING_ACTRONAIR_TO_HA[mode]
-            for mode in self._status.user_aircon_settings.supported_modes
-            if mode in HVAC_MODE_MAPPING_ACTRONAIR_TO_HA
-        ]
-        modes.append(HVACMode.OFF)
-        return modes
-
     @property
     def min_temp(self) -> float:
         """Return the minimum temperature that can be set."""
@@ -149,27 +136,23 @@ class ActronSystemClimate(ActronAirAcEntity, ActronAirClimateEntity):
         """Return the target temperature."""
         return self._status.user_aircon_settings.temperature_setpoint_cool_c
 
-    @actron_air_command
+    @handle_actron_api_errors
     async def async_set_fan_mode(self, fan_mode: str) -> None:
         """Set a new fan mode."""
-        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR[fan_mode]
+        api_fan_mode = FAN_MODE_MAPPING_HA_TO_ACTRONAIR.get(fan_mode)
         await self._status.user_aircon_settings.set_fan_mode(api_fan_mode)
 
-    @actron_air_command
+    @handle_actron_api_errors
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set the HVAC mode."""
-        ac_mode = HVAC_MODE_MAPPING_HA_TO_ACTRONAIR[hvac_mode]
+        ac_mode = HVAC_MODE_MAPPING_HA_TO_ACTRONAIR.get(hvac_mode)
         await self._status.ac_system.set_system_mode(ac_mode)
 
-    @actron_air_command
+    @handle_actron_api_errors
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set the temperature."""
-        if (temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="temperature_missing",
-            )
-        await self._status.user_aircon_settings.set_temperature(temperature=temperature)
+        temp = kwargs.get(ATTR_TEMPERATURE)
+        await self._status.user_aircon_settings.set_temperature(temperature=temp)
 
 
 class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
@@ -190,18 +173,6 @@ class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
         super().__init__(coordinator, zone)
         self._attr_unique_id: str = self._zone_identifier
 
-    @property
-    def hvac_modes(self) -> list[HVACMode]:
-        """Return the list of supported HVAC modes."""
-        status = self.coordinator.data
-        modes = [
-            HVAC_MODE_MAPPING_ACTRONAIR_TO_HA[mode]
-            for mode in status.user_aircon_settings.supported_modes
-            if mode in HVAC_MODE_MAPPING_ACTRONAIR_TO_HA
-        ]
-        modes.append(HVACMode.OFF)
-        return modes
-
     @property
     def min_temp(self) -> float:
         """Return the minimum temperature that can be set."""
@@ -241,18 +212,13 @@ class ActronZoneClimate(ActronAirZoneEntity, ActronAirClimateEntity):
         """Return the target temperature."""
         return self._zone.temperature_setpoint_cool_c
 
-    @actron_air_command
+    @handle_actron_api_errors
     async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
         """Set the HVAC mode."""
         is_enabled = hvac_mode != HVACMode.OFF
         await self._zone.enable(is_enabled)
 
-    @actron_air_command
+    @handle_actron_api_errors
     async def async_set_temperature(self, **kwargs: Any) -> None:
         """Set the temperature."""
-        if (temperature := kwargs.get(ATTR_TEMPERATURE)) is None:
-            raise ServiceValidationError(
-                translation_domain=DOMAIN,
-                translation_key="temperature_missing",
-            )
-        await self._zone.set_temperature(temperature=temperature)
+        await self._zone.set_temperature(temperature=kwargs.get(ATTR_TEMPERATURE))

homeassistant/components/actron_air/config_flow.py

@@ -23,7 +23,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
         self._user_code: str = ""
         self._verification_uri: str = ""
         self._expires_minutes: str = "30"
-        self.login_task: asyncio.Task[None] | None = None
+        self.login_task: asyncio.Task | None = None
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -38,10 +38,10 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
                 _LOGGER.error("OAuth2 flow failed: %s", err)
                 return self.async_abort(reason="oauth2_error")
 
-            self._device_code = device_code_response.device_code
-            self._user_code = device_code_response.user_code
-            self._verification_uri = device_code_response.verification_uri_complete
-            self._expires_minutes = str(device_code_response.expires_in // 60)
+            self._device_code = device_code_response["device_code"]
+            self._user_code = device_code_response["user_code"]
+            self._verification_uri = device_code_response["verification_uri_complete"]
+            self._expires_minutes = str(device_code_response["expires_in"] // 60)
 
         async def _wait_for_authorization() -> None:
             """Wait for the user to authorize the device."""
@@ -94,7 +94,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
             _LOGGER.error("Error getting user info: %s", err)
             return self.async_abort(reason="oauth2_error")
 
-        unique_id = user_data.sub
+        unique_id = str(user_data["id"])
         await self.async_set_unique_id(unique_id)
 
         # Check if this is a reauth flow
@@ -107,7 +107,7 @@ class ActronAirConfigFlow(ConfigFlow, domain=DOMAIN):
 
         self._abort_if_unique_id_configured()
         return self.async_create_entry(
-            title=user_data.email,
+            title=user_data["email"],
             data={CONF_API_TOKEN: self._api.refresh_token_value},
         )
 

homeassistant/components/actron_air/coordinator.py

@@ -6,12 +6,12 @@ from dataclasses import dataclass
 from datetime import timedelta
 
 from actron_neo_api import (
+    ActronAirACSystem,
     ActronAirAPI,
     ActronAirAPIError,
     ActronAirAuthError,
     ActronAirStatus,
 )
-from actron_neo_api.models.system import ActronAirSystemInfo
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
@@ -38,7 +38,7 @@ class ActronAirRuntimeData:
 type ActronAirConfigEntry = ConfigEntry[ActronAirRuntimeData]
 
 
-class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirStatus]):
+class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirACSystem]):
     """System coordinator for Actron Air integration."""
 
     def __init__(
@@ -46,7 +46,7 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirStatus]):
         hass: HomeAssistant,
         entry: ActronAirConfigEntry,
         api: ActronAirAPI,
-        system: ActronAirSystemInfo,
+        system: ActronAirACSystem,
     ) -> None:
         """Initialize the coordinator."""
         super().__init__(
@@ -57,7 +57,7 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirStatus]):
             config_entry=entry,
         )
         self.system = system
-        self.serial_number = system.serial
+        self.serial_number = system["serial"]
         self.api = api
         self.status = self.api.state_manager.get_status(self.serial_number)
         self.last_seen = dt_util.utcnow()
@@ -78,14 +78,7 @@ class ActronAirSystemCoordinator(DataUpdateCoordinator[ActronAirStatus]):
                 translation_placeholders={"error": repr(err)},
             ) from err
 
-        status = self.api.state_manager.get_status(self.serial_number)
-        if status is None:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="update_error",
-                translation_placeholders={"error": "Status not available"},
-            )
-        self.status = status
+        self.status = self.api.state_manager.get_status(self.serial_number)
         self.last_seen = dt_util.utcnow()
         return self.status
 

homeassistant/components/actron_air/diagnostics.py

@@ -1,35 +0,0 @@
-"""Diagnostics support for Actron Air."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from homeassistant.components.diagnostics import async_redact_data
-from homeassistant.const import CONF_API_TOKEN
-from homeassistant.core import HomeAssistant
-
-from .coordinator import ActronAirConfigEntry
-
-TO_REDACT = {CONF_API_TOKEN, "master_serial", "serial_number", "serial"}
-
-
-async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant,
-    entry: ActronAirConfigEntry,
-) -> dict[str, Any]:
-    """Return diagnostics for a config entry."""
-    coordinators: dict[int, Any] = {}
-    for idx, coordinator in enumerate(entry.runtime_data.system_coordinators.values()):
-        coordinators[idx] = {
-            "system": async_redact_data(
-                coordinator.system.model_dump(mode="json"), TO_REDACT
-            ),
-            "status": async_redact_data(
-                coordinator.data.model_dump(mode="json", exclude={"last_known_state"}),
-                TO_REDACT,
-            ),
-        }
-    return {
-        "entry_data": async_redact_data(entry.data, TO_REDACT),
-        "coordinators": coordinators,
-    }

homeassistant/components/actron_air/entity.py

@@ -14,17 +14,13 @@ from .const import DOMAIN
 from .coordinator import ActronAirSystemCoordinator
 
 
-def actron_air_command[_EntityT: ActronAirEntity, **_P](
+def handle_actron_api_errors[_EntityT: ActronAirEntity, **_P](
     func: Callable[Concatenate[_EntityT, _P], Coroutine[Any, Any, Any]],
 ) -> Callable[Concatenate[_EntityT, _P], Coroutine[Any, Any, None]]:
-    """Decorator for Actron Air API calls.
-
-    Handles ActronAirAPIError exceptions, and requests a coordinator update
-    to update the status of the devices as soon as possible.
-    """
+    """Decorate Actron Air API calls to handle ActronAirAPIError exceptions."""
 
     @wraps(func)
-    async def wrapper(self: _EntityT, /, *args: _P.args, **kwargs: _P.kwargs) -> None:
+    async def wrapper(self: _EntityT, *args: _P.args, **kwargs: _P.kwargs) -> None:
         """Wrap API calls with exception handling."""
         try:
             await func(self, *args, **kwargs)
@@ -34,7 +30,6 @@ def actron_air_command[_EntityT: ActronAirEntity, **_P](
                 translation_key="api_error",
                 translation_placeholders={"error": str(err)},
             ) from err
-        self.coordinator.async_set_updated_data(self.coordinator.data)
 
     return wrapper
 

homeassistant/components/actron_air/manifest.json

@@ -13,5 +13,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_polling",
   "quality_scale": "silver",
-  "requirements": ["actron-neo-api==0.5.6"]
+  "requirements": ["actron-neo-api==0.4.1"]
 }

homeassistant/components/actron_air/quality_scale.yaml

@@ -41,7 +41,7 @@ rules:
 
   # Gold
   devices: done
-  diagnostics: done
+  diagnostics: todo
   discovery-update-info:
     status: exempt
     comment: This integration uses DHCP discovery, however is cloud polling. Therefore there is no information to update.
@@ -54,12 +54,18 @@ rules:
   docs-troubleshooting: done
   docs-use-cases: done
   dynamic-devices: todo
-  entity-category: done
-  entity-device-class: todo
-  entity-disabled-by-default: todo
-  entity-translations: done
-  exception-translations: done
-  icon-translations: done
+  entity-category:
+    status: exempt
+    comment: This integration does not use entity categories.
+  entity-device-class:
+    status: exempt
+    comment: This integration does not use entity device classes.
+  entity-disabled-by-default:
+    status: exempt
+    comment: Not required for this integration at this stage.
+  entity-translations: todo
+  exception-translations: todo
+  icon-translations: todo
   reconfiguration-flow: todo
   repair-issues:
     status: exempt
@@ -69,4 +75,4 @@ rules:
   # Platinum
   async-dependency: done
   inject-websession: todo
-  strict-typing: done
+  strict-typing: todo

homeassistant/components/actron_air/strings.json

@@ -55,12 +55,6 @@
     "auth_error": {
       "message": "Authentication failed, please reauthenticate"
     },
-    "setup_connection_error": {
-      "message": "Failed to connect to the Actron Air API"
-    },
-    "temperature_missing": {
-      "message": "Provide a temperature value when adjusting the climate entity."
-    },
     "update_error": {
       "message": "An error occurred while retrieving data from the Actron Air API: {error}"
     }

homeassistant/components/actron_air/switch.py

@@ -10,7 +10,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from .coordinator import ActronAirConfigEntry, ActronAirSystemCoordinator
-from .entity import ActronAirAcEntity, actron_air_command
+from .entity import ActronAirAcEntity, handle_actron_api_errors
 
 PARALLEL_UPDATES = 0
 
@@ -105,12 +105,12 @@ class ActronAirSwitch(ActronAirAcEntity, SwitchEntity):
         """Return true if the switch is on."""
         return self.entity_description.is_on_fn(self.coordinator)
 
-    @actron_air_command
+    @handle_actron_api_errors
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the switch on."""
         await self.entity_description.set_fn(self.coordinator, True)
 
-    @actron_air_command
+    @handle_actron_api_errors
     async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the switch off."""
         await self.entity_description.set_fn(self.coordinator, False)

homeassistant/components/ai_task/media_source.py

@@ -25,7 +25,7 @@ async def async_get_media_source(hass: HomeAssistant) -> MediaSource:
     hass.data[DATA_MEDIA_SOURCE] = source = local_source.LocalSource(
         hass,
         DOMAIN,
-        "AI generated images",
+        "AI Generated Images",
         {IMAGE_DIR: str(media_dir)},
         f"/{DOMAIN}",
     )

homeassistant/components/ai_task/task.py

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

homeassistant/components/air_quality/condition.py

@@ -36,9 +36,7 @@ def _make_detected_condition(
 ) -> type[Condition]:
     """Create a detected condition for a binary sensor device class."""
     return make_entity_state_condition(
-        {BINARY_SENSOR_DOMAIN: DomainSpec(device_class=device_class)},
-        STATE_ON,
-        support_duration=True,
+        {BINARY_SENSOR_DOMAIN: DomainSpec(device_class=device_class)}, STATE_ON
     )
 
 
@@ -47,9 +45,7 @@ def _make_cleared_condition(
 ) -> type[Condition]:
     """Create a cleared condition for a binary sensor device class."""
     return make_entity_state_condition(
-        {BINARY_SENSOR_DOMAIN: DomainSpec(device_class=device_class)},
-        STATE_OFF,
-        support_duration=True,
+        {BINARY_SENSOR_DOMAIN: DomainSpec(device_class=device_class)}, STATE_OFF
     )
 
 

homeassistant/components/air_quality/conditions.yaml

@@ -249,11 +249,6 @@
 .condition_binary_common: &condition_binary_common
   fields:
     behavior: *condition_behavior
-    for:
-      required: true
-      default: 00:00:00
-      selector:
-        duration:
 
 is_gas_detected:
   <<: *condition_binary_common

homeassistant/components/air_quality/strings.json

@@ -1,20 +1,25 @@
 {
   "common": {
-    "condition_behavior_name": "Condition passes if",
-    "condition_for_name": "For at least",
-    "condition_threshold_name": "Threshold type",
-    "trigger_behavior_name": "Trigger when",
-    "trigger_for_name": "For at least",
-    "trigger_threshold_name": "Threshold type"
+    "condition_behavior_description": "How the value should match on the targeted entities.",
+    "condition_behavior_name": "Behavior",
+    "condition_threshold_description": "What to test for and threshold values.",
+    "condition_threshold_name": "Threshold configuration",
+    "trigger_behavior_description": "The behavior of the targeted entities to trigger on.",
+    "trigger_behavior_name": "Behavior",
+    "trigger_threshold_changed_description": "Which changes to trigger on and threshold values.",
+    "trigger_threshold_crossed_description": "Which threshold crossing to trigger on and threshold values.",
+    "trigger_threshold_name": "Threshold configuration"
   },
   "conditions": {
     "is_co2_value": {
       "description": "Tests the carbon dioxide level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -24,10 +29,8 @@
       "description": "Tests if one or more carbon monoxide sensors are cleared.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::condition_for_name%]"
         }
       },
       "name": "Carbon monoxide cleared"
@@ -36,10 +39,8 @@
       "description": "Tests if one or more carbon monoxide sensors are detecting carbon monoxide.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::condition_for_name%]"
         }
       },
       "name": "Carbon monoxide detected"
@@ -48,9 +49,11 @@
       "description": "Tests the carbon monoxide level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -60,10 +63,8 @@
       "description": "Tests if one or more gas sensors are cleared.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::condition_for_name%]"
         }
       },
       "name": "Gas cleared"
@@ -72,10 +73,8 @@
       "description": "Tests if one or more gas sensors are detecting gas.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::condition_for_name%]"
         }
       },
       "name": "Gas detected"
@@ -84,9 +83,11 @@
       "description": "Tests the nitrous oxide level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -96,9 +97,11 @@
       "description": "Tests the nitrogen dioxide level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -108,9 +111,11 @@
       "description": "Tests the nitrogen monoxide level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -120,9 +125,11 @@
       "description": "Tests the ozone level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -132,9 +139,11 @@
       "description": "Tests the PM10 level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -144,9 +153,11 @@
       "description": "Tests the PM1 level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -156,9 +167,11 @@
       "description": "Tests the PM2.5 level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -168,9 +181,11 @@
       "description": "Tests the PM4 level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -180,10 +195,8 @@
       "description": "Tests if one or more smoke sensors are cleared.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::condition_for_name%]"
         }
       },
       "name": "Smoke cleared"
@@ -192,10 +205,8 @@
       "description": "Tests if one or more smoke sensors are detecting smoke.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::condition_for_name%]"
         }
       },
       "name": "Smoke detected"
@@ -204,9 +215,11 @@
       "description": "Tests the sulphur dioxide level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -216,9 +229,11 @@
       "description": "Tests the volatile organic compounds ratio of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -228,9 +243,11 @@
       "description": "Tests the volatile organic compounds level of one or more entities.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::condition_behavior_description%]",
           "name": "[%key:component::air_quality::common::condition_behavior_name%]"
         },
         "threshold": {
+          "description": "[%key:component::air_quality::common::condition_threshold_description%]",
           "name": "[%key:component::air_quality::common::condition_threshold_name%]"
         }
       },
@@ -258,6 +275,7 @@
       "description": "Triggers after one or more carbon dioxide levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -267,12 +285,11 @@
       "description": "Triggers after one or more carbon dioxide levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -282,6 +299,7 @@
       "description": "Triggers after one or more carbon monoxide levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -291,10 +309,8 @@
       "description": "Triggers after one or more carbon monoxide sensors stop detecting carbon monoxide.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Carbon monoxide cleared"
@@ -303,12 +319,11 @@
       "description": "Triggers after one or more carbon monoxide levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -318,10 +333,8 @@
       "description": "Triggers after one or more carbon monoxide sensors start detecting carbon monoxide.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Carbon monoxide detected"
@@ -330,10 +343,8 @@
       "description": "Triggers after one or more gas sensors stop detecting gas.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Gas cleared"
@@ -342,10 +353,8 @@
       "description": "Triggers after one or more gas sensors start detecting gas.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Gas detected"
@@ -354,6 +363,7 @@
       "description": "Triggers after one or more nitrous oxide levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -363,12 +373,11 @@
       "description": "Triggers after one or more nitrous oxide levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -378,6 +387,7 @@
       "description": "Triggers after one or more nitrogen dioxide levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -387,12 +397,11 @@
       "description": "Triggers after one or more nitrogen dioxide levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -402,6 +411,7 @@
       "description": "Triggers after one or more nitrogen monoxide levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -411,12 +421,11 @@
       "description": "Triggers after one or more nitrogen monoxide levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -426,6 +435,7 @@
       "description": "Triggers after one or more ozone levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -435,12 +445,11 @@
       "description": "Triggers after one or more ozone levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -450,6 +459,7 @@
       "description": "Triggers after one or more PM10 levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -459,12 +469,11 @@
       "description": "Triggers after one or more PM10 levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -474,6 +483,7 @@
       "description": "Triggers after one or more PM1 levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -483,12 +493,11 @@
       "description": "Triggers after one or more PM1 levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -498,6 +507,7 @@
       "description": "Triggers after one or more PM2.5 levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -507,12 +517,11 @@
       "description": "Triggers after one or more PM2.5 levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -522,6 +531,7 @@
       "description": "Triggers after one or more PM4 levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -531,12 +541,11 @@
       "description": "Triggers after one or more PM4 levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -546,10 +555,8 @@
       "description": "Triggers after one or more smoke sensors stop detecting smoke.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Smoke cleared"
@@ -558,10 +565,8 @@
       "description": "Triggers after one or more smoke sensors start detecting smoke.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
         }
       },
       "name": "Smoke detected"
@@ -570,6 +575,7 @@
       "description": "Triggers after one or more sulphur dioxide levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -579,12 +585,11 @@
       "description": "Triggers after one or more sulphur dioxide levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -594,6 +599,7 @@
       "description": "Triggers after one or more volatile organic compound levels change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -603,12 +609,11 @@
       "description": "Triggers after one or more volatile organic compounds levels cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -618,6 +623,7 @@
       "description": "Triggers after one or more volatile organic compound ratios change.",
       "fields": {
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_changed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },
@@ -627,12 +633,11 @@
       "description": "Triggers after one or more volatile organic compounds ratios cross a threshold.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::air_quality::common::trigger_behavior_description%]",
           "name": "[%key:component::air_quality::common::trigger_behavior_name%]"
         },
-        "for": {
-          "name": "[%key:component::air_quality::common::trigger_for_name%]"
-        },
         "threshold": {
+          "description": "[%key:component::air_quality::common::trigger_threshold_crossed_description%]",
           "name": "[%key:component::air_quality::common::trigger_threshold_name%]"
         }
       },

homeassistant/components/air_quality/triggers.yaml

@@ -9,11 +9,6 @@
           - first
           - last
           - any
-  for: &trigger_for
-    required: true
-    default: 00:00:00
-    selector:
-      duration:
 
 # --- Unit lists for multi-unit pollutants ---
 
@@ -168,7 +163,6 @@
 # Binary sensor detected/cleared trigger fields
 .trigger_binary_fields: &trigger_binary_fields
   behavior: *trigger_behavior
-  for: *trigger_for
 
 # --- Binary sensor targets ---
 
@@ -300,7 +294,6 @@ co_crossed_threshold:
   target: *target_co_sensor
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -327,7 +320,6 @@ co2_crossed_threshold:
   target: *target_co2
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -352,7 +344,6 @@ pm1_crossed_threshold:
   target: *target_pm1
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -377,7 +368,6 @@ pm25_crossed_threshold:
   target: *target_pm25
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -402,7 +392,6 @@ pm4_crossed_threshold:
   target: *target_pm4
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -427,7 +416,6 @@ pm10_crossed_threshold:
   target: *target_pm10
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -454,7 +442,6 @@ ozone_crossed_threshold:
   target: *target_ozone
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -483,7 +470,6 @@ voc_crossed_threshold:
   target: *target_voc
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -512,7 +498,6 @@ voc_ratio_crossed_threshold:
   target: *target_voc_ratio
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -541,7 +526,6 @@ no_crossed_threshold:
   target: *target_no
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -570,7 +554,6 @@ no2_crossed_threshold:
   target: *target_no2
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -597,7 +580,6 @@ n2o_crossed_threshold:
   target: *target_n2o
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:
@@ -624,7 +606,6 @@ so2_crossed_threshold:
   target: *target_so2
   fields:
     behavior: *trigger_behavior
-    for: *trigger_for
     threshold:
       required: true
       selector:

homeassistant/components/airly/config_flow.py

@@ -12,11 +12,11 @@ from airly.exceptions import AirlyError
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE
+from homeassistant.const import CONF_API_KEY, CONF_LATITUDE, CONF_LONGITUDE, CONF_NAME
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 
-from .const import CONF_USE_NEAREST, DEFAULT_NAME, DOMAIN, NO_AIRLY_SENSORS
+from .const import CONF_USE_NEAREST, DOMAIN, NO_AIRLY_SENSORS
 
 DESCRIPTION_PLACEHOLDERS = {
     "developer_registration_url": "https://developer.airly.eu/register",
@@ -45,16 +45,16 @@ class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
             try:
                 location_point_valid = await check_location(
                     websession,
-                    user_input[CONF_API_KEY],
-                    user_input[CONF_LATITUDE],
-                    user_input[CONF_LONGITUDE],
+                    user_input["api_key"],
+                    user_input["latitude"],
+                    user_input["longitude"],
                 )
                 if not location_point_valid:
                     location_nearest_valid = await check_location(
                         websession,
-                        user_input[CONF_API_KEY],
-                        user_input[CONF_LATITUDE],
-                        user_input[CONF_LONGITUDE],
+                        user_input["api_key"],
+                        user_input["latitude"],
+                        user_input["longitude"],
                         use_nearest=True,
                     )
             except AirlyError as err:
@@ -68,7 +68,7 @@ class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
                         return self.async_abort(reason="wrong_location")
                     use_nearest = True
                 return self.async_create_entry(
-                    title=DEFAULT_NAME,
+                    title=user_input[CONF_NAME],
                     data={**user_input, CONF_USE_NEAREST: use_nearest},
                 )
 
@@ -83,6 +83,9 @@ class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
                     vol.Optional(
                         CONF_LONGITUDE, default=self.hass.config.longitude
                     ): cv.longitude,
+                    vol.Optional(
+                        CONF_NAME, default=self.hass.config.location_name
+                    ): str,
                 }
             ),
             errors=errors,

homeassistant/components/airly/const.py

@@ -37,5 +37,3 @@ MAX_UPDATE_INTERVAL: Final = 90
 MIN_UPDATE_INTERVAL: Final = 5
 NO_AIRLY_SENSORS: Final = "There are no Airly sensors in this area yet."
 URL = "https://airly.org/map/#{latitude},{longitude}"
-
-DEFAULT_NAME: Final = "Airly"

homeassistant/components/airly/sensor.py

@@ -127,7 +127,7 @@ SENSOR_TYPES: tuple[AirlySensorEntityDescription, ...] = (
     ),
     AirlySensorEntityDescription(
         key=ATTR_API_CO,
-        device_class=SensorDeviceClass.CO,
+        translation_key="co",
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         state_class=SensorStateClass.MEASUREMENT,
         suggested_display_precision=0,
@@ -178,7 +178,7 @@ async def async_setup_entry(
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Airly sensor entities based on a config entry."""
-    name = entry.data.get(CONF_NAME) or entry.title
+    name = entry.data[CONF_NAME]
 
     coordinator = entry.runtime_data
 

homeassistant/components/airly/strings.json

@@ -13,7 +13,8 @@
         "data": {
           "api_key": "[%key:common::config_flow::data::api_key%]",
           "latitude": "[%key:common::config_flow::data::latitude%]",
-          "longitude": "[%key:common::config_flow::data::longitude%]"
+          "longitude": "[%key:common::config_flow::data::longitude%]",
+          "name": "[%key:common::config_flow::data::name%]"
         },
         "description": "To generate API key go to {developer_registration_url}"
       }
@@ -23,6 +24,9 @@
     "sensor": {
       "caqi": {
         "name": "Common air quality index"
+      },
+      "co": {
+        "name": "[%key:component::sensor::entity_component::carbon_monoxide::name%]"
       }
     }
   },

homeassistant/components/airos/__init__.py

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

homeassistant/components/airos/binary_sensor.py

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

homeassistant/components/airos/button.py

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

homeassistant/components/airos/const.py

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

homeassistant/components/airos/coordinator.py

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

homeassistant/components/airos/diagnostics.py

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

homeassistant/components/airos/sensor.py

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

homeassistant/components/airos/strings.json

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

homeassistant/components/airos/update.py

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

homeassistant/components/airtouch5/config_flow.py

@@ -36,8 +36,6 @@ class AirTouch5ConfigFlow(ConfigFlow, domain=DOMAIN):
                 _LOGGER.exception("Unexpected exception")
                 errors = {"base": "cannot_connect"}
             else:
-                # Uses the host/IP value from CONF_HOST as unique ID, which is no longer allowed
-                # pylint: disable-next=hass-unique-id-ip-based
                 await self.async_set_unique_id(user_input[CONF_HOST])
                 self._abort_if_unique_id_configured()
                 return self.async_create_entry(

homeassistant/components/alarm_control_panel/condition.py

@@ -4,7 +4,6 @@ from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.automation import DomainSpec
 from homeassistant.helpers.condition import (
-    ENTITY_STATE_CONDITION_SCHEMA_ANY_ALL_FOR,
     Condition,
     EntityStateConditionBase,
     make_entity_state_condition,
@@ -26,7 +25,6 @@ class EntityStateRequiredFeaturesCondition(EntityStateConditionBase):
     """State condition."""
 
     _required_features: int
-    _schema = ENTITY_STATE_CONDITION_SCHEMA_ANY_ALL_FOR
 
     def entity_filter(self, entities: set[str]) -> set[str]:
         """Filter entities of this domain with the required features."""
@@ -84,11 +82,9 @@ CONDITIONS: dict[str, type[Condition]] = {
         AlarmControlPanelState.ARMED_VACATION,
         AlarmControlPanelEntityFeature.ARM_VACATION,
     ),
-    "is_disarmed": make_entity_state_condition(
-        DOMAIN, AlarmControlPanelState.DISARMED, support_duration=True
-    ),
+    "is_disarmed": make_entity_state_condition(DOMAIN, AlarmControlPanelState.DISARMED),
     "is_triggered": make_entity_state_condition(
-        DOMAIN, AlarmControlPanelState.TRIGGERED, support_duration=True
+        DOMAIN, AlarmControlPanelState.TRIGGERED
     ),
 }
 

homeassistant/components/alarm_control_panel/conditions.yaml

@@ -1,9 +1,9 @@
 .condition_common: &condition_common
-  target: &condition_common_target
+  target:
     entity:
       domain: alarm_control_panel
   fields: &condition_common_fields
-    behavior: &condition_common_behavior
+    behavior:
       required: true
       default: any
       selector:
@@ -13,20 +13,10 @@
             - all
             - any
 
-.condition_common_for: &condition_common_for
-  target: *condition_common_target
-  fields: &condition_common_for_fields
-    behavior: *condition_common_behavior
-    for:
-      required: true
-      default: 00:00:00
-      selector:
-        duration:
-
 is_armed: *condition_common
 
 is_armed_away:
-  fields: *condition_common_for_fields
+  fields: *condition_common_fields
   target:
     entity:
       domain: alarm_control_panel
@@ -34,7 +24,7 @@ is_armed_away:
         - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_AWAY
 
 is_armed_home:
-  fields: *condition_common_for_fields
+  fields: *condition_common_fields
   target:
     entity:
       domain: alarm_control_panel
@@ -42,7 +32,7 @@ is_armed_home:
         - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_HOME
 
 is_armed_night:
-  fields: *condition_common_for_fields
+  fields: *condition_common_fields
   target:
     entity:
       domain: alarm_control_panel
@@ -50,13 +40,13 @@ is_armed_night:
         - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_NIGHT
 
 is_armed_vacation:
-  fields: *condition_common_for_fields
+  fields: *condition_common_fields
   target:
     entity:
       domain: alarm_control_panel
       supported_features:
         - alarm_control_panel.AlarmControlPanelEntityFeature.ARM_VACATION
 
-is_disarmed: *condition_common_for
+is_disarmed: *condition_common
 
-is_triggered: *condition_common_for
+is_triggered: *condition_common

homeassistant/components/alarm_control_panel/strings.json

@@ -1,15 +1,16 @@
 {
   "common": {
-    "condition_behavior_name": "Condition passes if",
-    "condition_for_name": "For at least",
-    "trigger_behavior_name": "Trigger when",
-    "trigger_for_name": "For at least"
+    "condition_behavior_description": "How the state should match on the targeted alarms.",
+    "condition_behavior_name": "Behavior",
+    "trigger_behavior_description": "The behavior of the targeted alarms to trigger on.",
+    "trigger_behavior_name": "Behavior"
   },
   "conditions": {
     "is_armed": {
       "description": "Tests if one or more alarms are armed.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
         }
       },
@@ -19,10 +20,8 @@
       "description": "Tests if one or more alarms are armed in away mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::condition_for_name%]"
         }
       },
       "name": "Alarm is armed away"
@@ -31,10 +30,8 @@
       "description": "Tests if one or more alarms are armed in home mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::condition_for_name%]"
         }
       },
       "name": "Alarm is armed home"
@@ -43,10 +40,8 @@
       "description": "Tests if one or more alarms are armed in night mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::condition_for_name%]"
         }
       },
       "name": "Alarm is armed night"
@@ -55,10 +50,8 @@
       "description": "Tests if one or more alarms are armed in vacation mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::condition_for_name%]"
         }
       },
       "name": "Alarm is armed vacation"
@@ -67,10 +60,8 @@
       "description": "Tests if one or more alarms are disarmed.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::condition_for_name%]"
         }
       },
       "name": "Alarm is disarmed"
@@ -79,10 +70,8 @@
       "description": "Tests if one or more alarms are triggered.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::condition_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::condition_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::condition_for_name%]"
         }
       },
       "name": "Alarm is triggered"
@@ -253,10 +242,8 @@
       "description": "Triggers after one or more alarms become armed, regardless of the mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed"
@@ -265,10 +252,8 @@
       "description": "Triggers after one or more alarms become armed in away mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed away"
@@ -277,10 +262,8 @@
       "description": "Triggers after one or more alarms become armed in home mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed home"
@@ -289,10 +272,8 @@
       "description": "Triggers after one or more alarms become armed in night mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed night"
@@ -301,10 +282,8 @@
       "description": "Triggers after one or more alarms become armed in vacation mode.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm armed vacation"
@@ -313,10 +292,8 @@
       "description": "Triggers after one or more alarms become disarmed.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm disarmed"
@@ -325,10 +302,8 @@
       "description": "Triggers after one or more alarms become triggered.",
       "fields": {
         "behavior": {
+          "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
-        },
-        "for": {
-          "name": "[%key:component::alarm_control_panel::common::trigger_for_name%]"
         }
       },
       "name": "Alarm triggered"

homeassistant/components/alarm_control_panel/triggers.yaml

@@ -13,11 +13,6 @@
             - last
             - any
           translation_key: trigger_behavior
-    for:
-      required: true
-      default: 00:00:00
-      selector:
-        duration:
 
 armed: *trigger_common
 

homeassistant/components/alarmdecoder/config_flow.py

@@ -3,10 +3,10 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, cast
+from typing import Any
 
 from adext import AdExt
-from alarmdecoder.devices import Device, SerialDevice, SocketDevice
+from alarmdecoder.devices import SerialDevice, SocketDevice
 from alarmdecoder.util import NoDeviceError
 import voluptuous as vol
 
@@ -102,21 +102,16 @@ class AlarmDecoderFlowHandler(ConfigFlow, domain=DOMAIN):
                 self._async_current_entries(), user_input, self.protocol
             ):
                 return self.async_abort(reason="already_configured")
-            connection: dict[str, Any] = {}
+            connection = {}
             baud = None
-            device: Device
             if self.protocol == PROTOCOL_SOCKET:
-                host = connection[CONF_HOST] = cast(str, user_input[CONF_HOST])
-                port = connection[CONF_PORT] = cast(int, user_input[CONF_PORT])
-                title: str = f"{host}:{port}"
+                host = connection[CONF_HOST] = user_input[CONF_HOST]
+                port = connection[CONF_PORT] = user_input[CONF_PORT]
+                title = f"{host}:{port}"
                 device = SocketDevice(interface=(host, port))
             if self.protocol == PROTOCOL_SERIAL:
-                path = connection[CONF_DEVICE_PATH] = cast(
-                    str, user_input[CONF_DEVICE_PATH]
-                )
-                baud = connection[CONF_DEVICE_BAUD] = cast(
-                    int, user_input[CONF_DEVICE_BAUD]
-                )
+                path = connection[CONF_DEVICE_PATH] = user_input[CONF_DEVICE_PATH]
+                baud = connection[CONF_DEVICE_BAUD] = user_input[CONF_DEVICE_BAUD]
                 title = path
                 device = SerialDevice(interface=path)
 
@@ -137,7 +132,6 @@ class AlarmDecoderFlowHandler(ConfigFlow, domain=DOMAIN):
                 _LOGGER.exception("Unexpected exception during AlarmDecoder setup")
                 errors["base"] = "unknown"
 
-        schema: vol.Schema
         if self.protocol == PROTOCOL_SOCKET:
             schema = vol.Schema(
                 {

homeassistant/components/alexa_devices/coordinator.py

@@ -54,16 +54,7 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
             entry.data[CONF_PASSWORD],
             entry.data[CONF_LOGIN_DATA],
         )
-        device_registry = dr.async_get(hass)
-        self.previous_devices: set[str] = {
-            identifier
-            for device in device_registry.devices.get_devices_for_config_entry_id(
-                entry.entry_id
-            )
-            if device.entry_type != dr.DeviceEntryType.SERVICE
-            for identifier_domain, identifier in device.identifiers
-            if identifier_domain == DOMAIN
-        }
+        self.previous_devices: set[str] = set()
 
     async def _async_update_data(self) -> dict[str, AmazonDevice]:
         """Update device data."""

homeassistant/components/alexa_devices/manifest.json

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

homeassistant/components/amcrest/__init__.py

@@ -39,6 +39,7 @@ from homeassistant.helpers.typing import ConfigType
 from .binary_sensor import BINARY_SENSOR_KEYS, BINARY_SENSORS, check_binary_sensors
 from .camera import STREAM_SOURCE_LIST
 from .const import (
+    CAMERAS,
     COMM_RETRIES,
     COMM_TIMEOUT,
     DATA_AMCREST,
@@ -358,7 +359,7 @@ def _start_event_monitor(
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Amcrest IP Camera component."""
-    hass.data.setdefault(DATA_AMCREST, {DEVICES: {}})
+    hass.data.setdefault(DATA_AMCREST, {DEVICES: {}, CAMERAS: []})
 
     for device in config[DOMAIN]:
         name: str = device[CONF_NAME]

homeassistant/components/amcrest/camera.py

@@ -12,11 +12,13 @@ import aiohttp
 from aiohttp import web
 from amcrest import AmcrestError
 from haffmpeg.camera import CameraMjpeg
+import voluptuous as vol
 
 from homeassistant.components.camera import Camera, CameraEntityFeature
 from homeassistant.components.ffmpeg import FFmpegManager, get_ffmpeg_manager
-from homeassistant.const import CONF_NAME, STATE_OFF, STATE_ON
+from homeassistant.const import ATTR_ENTITY_ID, CONF_NAME, STATE_OFF, STATE_ON
 from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.aiohttp_client import (
     async_aiohttp_proxy_stream,
     async_aiohttp_proxy_web,
@@ -27,13 +29,11 @@ from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType
 
 from .const import (
-    ATTR_COLOR_BW,
     CAMERA_WEB_SESSION_TIMEOUT,
-    CBW,
+    CAMERAS,
     COMM_TIMEOUT,
     DATA_AMCREST,
     DEVICES,
-    MOV,
     RESOLUTION_TO_STREAM,
     SERVICE_UPDATE,
     SNAPSHOT_TIMEOUT,
@@ -49,11 +49,65 @@ SCAN_INTERVAL = timedelta(seconds=15)
 
 STREAM_SOURCE_LIST = ["snapshot", "mjpeg", "rtsp"]
 
+_ATTR_PTZ_TT = "travel_time"
+_ATTR_PTZ_MOV = "movement"
+_MOV = [
+    "zoom_out",
+    "zoom_in",
+    "right",
+    "left",
+    "up",
+    "down",
+    "right_down",
+    "right_up",
+    "left_down",
+    "left_up",
+]
 _ZOOM_ACTIONS = ["ZoomWide", "ZoomTele"]
 _MOVE_1_ACTIONS = ["Right", "Left", "Up", "Down"]
 _MOVE_2_ACTIONS = ["RightDown", "RightUp", "LeftDown", "LeftUp"]
 _ACTION = _ZOOM_ACTIONS + _MOVE_1_ACTIONS + _MOVE_2_ACTIONS
 
+_DEFAULT_TT = 0.2
+
+_ATTR_PRESET = "preset"
+_ATTR_COLOR_BW = "color_bw"
+
+_CBW_COLOR = "color"
+_CBW_AUTO = "auto"
+_CBW_BW = "bw"
+_CBW = [_CBW_COLOR, _CBW_AUTO, _CBW_BW]
+
+_SRV_SCHEMA = vol.Schema({vol.Optional(ATTR_ENTITY_ID): cv.comp_entity_ids})
+_SRV_GOTO_SCHEMA = _SRV_SCHEMA.extend(
+    {vol.Required(_ATTR_PRESET): vol.All(vol.Coerce(int), vol.Range(min=1))}
+)
+_SRV_CBW_SCHEMA = _SRV_SCHEMA.extend({vol.Required(_ATTR_COLOR_BW): vol.In(_CBW)})
+_SRV_PTZ_SCHEMA = _SRV_SCHEMA.extend(
+    {
+        vol.Required(_ATTR_PTZ_MOV): vol.In(_MOV),
+        vol.Optional(_ATTR_PTZ_TT, default=_DEFAULT_TT): cv.small_float,
+    }
+)
+
+CAMERA_SERVICES = {
+    "enable_recording": (_SRV_SCHEMA, "async_enable_recording", ()),
+    "disable_recording": (_SRV_SCHEMA, "async_disable_recording", ()),
+    "enable_audio": (_SRV_SCHEMA, "async_enable_audio", ()),
+    "disable_audio": (_SRV_SCHEMA, "async_disable_audio", ()),
+    "enable_motion_recording": (_SRV_SCHEMA, "async_enable_motion_recording", ()),
+    "disable_motion_recording": (_SRV_SCHEMA, "async_disable_motion_recording", ()),
+    "goto_preset": (_SRV_GOTO_SCHEMA, "async_goto_preset", (_ATTR_PRESET,)),
+    "set_color_bw": (_SRV_CBW_SCHEMA, "async_set_color_bw", (_ATTR_COLOR_BW,)),
+    "start_tour": (_SRV_SCHEMA, "async_start_tour", ()),
+    "stop_tour": (_SRV_SCHEMA, "async_stop_tour", ()),
+    "ptz_control": (
+        _SRV_PTZ_SCHEMA,
+        "async_ptz_control",
+        (_ATTR_PTZ_MOV, _ATTR_PTZ_TT),
+    ),
+}
+
 _BOOL_TO_STATE = {True: STATE_ON, False: STATE_OFF}
 
 
@@ -221,7 +275,7 @@ class AmcrestCam(Camera):
                 self._motion_recording_enabled
             )
         if self._color_bw is not None:
-            attr[ATTR_COLOR_BW] = self._color_bw
+            attr[_ATTR_COLOR_BW] = self._color_bw
         return attr
 
     @property
@@ -268,7 +322,15 @@ class AmcrestCam(Camera):
         self.async_schedule_update_ha_state(True)
 
     async def async_added_to_hass(self) -> None:
-        """Subscribe to signals."""
+        """Subscribe to signals and add camera to list."""
+        self._unsub_dispatcher.extend(
+            async_dispatcher_connect(
+                self.hass,
+                service_signal(service, self.entity_id),
+                getattr(self, callback_name),
+            )
+            for service, (_, callback_name, _) in CAMERA_SERVICES.items()
+        )
         self._unsub_dispatcher.append(
             async_dispatcher_connect(
                 self.hass,
@@ -276,9 +338,11 @@ class AmcrestCam(Camera):
                 self.async_on_demand_update,
             )
         )
+        self.hass.data[DATA_AMCREST][CAMERAS].append(self.entity_id)
 
     async def async_will_remove_from_hass(self) -> None:
-        """Disconnect from signals."""
+        """Remove camera from list and disconnect from signals."""
+        self.hass.data[DATA_AMCREST][CAMERAS].remove(self.entity_id)
         for unsub_dispatcher in self._unsub_dispatcher:
             unsub_dispatcher()
 
@@ -392,7 +456,7 @@ class AmcrestCam(Camera):
 
     async def async_ptz_control(self, movement: str, travel_time: float) -> None:
         """Move or zoom camera in specified direction."""
-        code = _ACTION[MOV.index(movement)]
+        code = _ACTION[_MOV.index(movement)]
 
         kwargs = {"code": code, "arg1": 0, "arg2": 0, "arg3": 0}
         if code in _MOVE_1_ACTIONS:
@@ -549,10 +613,10 @@ class AmcrestCam(Camera):
             )
 
     async def _async_get_color_mode(self) -> str:
-        return CBW[await self._api.async_day_night_color]
+        return _CBW[await self._api.async_day_night_color]
 
     async def _async_set_color_mode(self, cbw: str) -> None:
-        await self._api.async_set_day_night_color(CBW.index(cbw), channel=0)
+        await self._api.async_set_day_night_color(_CBW.index(cbw), channel=0)
 
     async def _async_set_color_bw(self, cbw: str) -> None:
         """Set camera color mode."""

homeassistant/components/amcrest/const.py

@@ -2,6 +2,7 @@
 
 DOMAIN = "amcrest"
 DATA_AMCREST = DOMAIN
+CAMERAS = "cameras"
 DEVICES = "devices"
 
 BINARY_SENSOR_SCAN_INTERVAL_SECS = 5
@@ -16,18 +17,3 @@ SERVICE_UPDATE = "update"
 
 RESOLUTION_LIST = {"high": 0, "low": 1}
 RESOLUTION_TO_STREAM = {0: "Main", 1: "Extra"}
-
-ATTR_COLOR_BW = "color_bw"
-CBW = ["color", "auto", "bw"]
-MOV = [
-    "zoom_out",
-    "zoom_in",
-    "right",
-    "left",
-    "up",
-    "down",
-    "right_down",
-    "right_up",
-    "left_down",
-    "left_up",
-]

homeassistant/components/amcrest/services.py

@@ -1,67 +1,62 @@
-"""Services for Amcrest IP cameras."""
+"""Support for Amcrest IP cameras."""
 
 from __future__ import annotations
 
-import voluptuous as vol
+from homeassistant.auth.models import User
+from homeassistant.auth.permissions.const import POLICY_CONTROL
+from homeassistant.const import ATTR_ENTITY_ID, ENTITY_MATCH_ALL, ENTITY_MATCH_NONE
+from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.exceptions import Unauthorized, UnknownUser
+from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.service import async_extract_entity_ids
 
-from homeassistant.components.camera import DOMAIN as CAMERA_DOMAIN
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.helpers import config_validation as cv, service
-
-from .const import ATTR_COLOR_BW, CBW, DOMAIN, MOV
-
-_ATTR_PRESET = "preset"
-_ATTR_PTZ_MOV = "movement"
-_ATTR_PTZ_TT = "travel_time"
-_DEFAULT_TT = 0.2
+from .camera import CAMERA_SERVICES
+from .const import CAMERAS, DATA_AMCREST, DOMAIN
+from .helpers import service_signal
 
 
 @callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Set up the Amcrest IP Camera services."""
-    for service_name, func in (
-        ("enable_recording", "async_enable_recording"),
-        ("disable_recording", "async_disable_recording"),
-        ("enable_audio", "async_enable_audio"),
-        ("disable_audio", "async_disable_audio"),
-        ("enable_motion_recording", "async_enable_motion_recording"),
-        ("disable_motion_recording", "async_disable_motion_recording"),
-        ("start_tour", "async_start_tour"),
-        ("stop_tour", "async_stop_tour"),
-    ):
-        service.async_register_platform_entity_service(
-            hass,
-            DOMAIN,
-            service_name,
-            entity_domain=CAMERA_DOMAIN,
-            schema=None,
-            func=func,
-        )
 
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        "goto_preset",
-        entity_domain=CAMERA_DOMAIN,
-        schema={vol.Required(_ATTR_PRESET): vol.All(vol.Coerce(int), vol.Range(min=1))},
-        func="async_goto_preset",
-    )
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        "set_color_bw",
-        entity_domain=CAMERA_DOMAIN,
-        schema={vol.Required(ATTR_COLOR_BW): vol.In(CBW)},
-        func="async_set_color_bw",
-    )
-    service.async_register_platform_entity_service(
-        hass,
-        DOMAIN,
-        "ptz_control",
-        entity_domain=CAMERA_DOMAIN,
-        schema={
-            vol.Required(_ATTR_PTZ_MOV): vol.In(MOV),
-            vol.Optional(_ATTR_PTZ_TT, default=_DEFAULT_TT): cv.small_float,
-        },
-        func="async_ptz_control",
-    )
+    def have_permission(user: User | None, entity_id: str) -> bool:
+        return not user or user.permissions.check_entity(entity_id, POLICY_CONTROL)
+
+    async def async_extract_from_service(call: ServiceCall) -> list[str]:
+        if call.context.user_id:
+            user = await hass.auth.async_get_user(call.context.user_id)
+            if user is None:
+                raise UnknownUser(context=call.context)
+        else:
+            user = None
+
+        if call.data.get(ATTR_ENTITY_ID) == ENTITY_MATCH_ALL:
+            # Return all entity_ids user has permission to control.
+            return [
+                entity_id
+                for entity_id in hass.data[DATA_AMCREST][CAMERAS]
+                if have_permission(user, entity_id)
+            ]
+
+        if call.data.get(ATTR_ENTITY_ID) == ENTITY_MATCH_NONE:
+            return []
+
+        call_ids = await async_extract_entity_ids(call)
+        entity_ids = []
+        for entity_id in hass.data[DATA_AMCREST][CAMERAS]:
+            if entity_id not in call_ids:
+                continue
+            if not have_permission(user, entity_id):
+                raise Unauthorized(
+                    context=call.context, entity_id=entity_id, permission=POLICY_CONTROL
+                )
+            entity_ids.append(entity_id)
+        return entity_ids
+
+    async def async_service_handler(call: ServiceCall) -> None:
+        args = [call.data[arg] for arg in CAMERA_SERVICES[call.service][2]]
+        for entity_id in await async_extract_from_service(call):
+            async_dispatcher_send(hass, service_signal(call.service, entity_id), *args)
+
+    for service, params in CAMERA_SERVICES.items():
+        hass.services.async_register(DOMAIN, service, async_service_handler, params[0])

homeassistant/components/analytics_insights/__init__.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 
 from python_homeassistant_analytics import (
-    Environment,
     HomeassistantAnalyticsClient,
     HomeassistantAnalyticsConnectionError,
 )
@@ -39,7 +38,7 @@ async def async_setup_entry(
     client = HomeassistantAnalyticsClient(session=async_get_clientsession(hass))
 
     try:
-        integrations = await client.get_integrations(Environment.NEXT)
+        integrations = await client.get_integrations()
     except HomeassistantAnalyticsConnectionError as ex:
         raise ConfigEntryNotReady("Could not fetch integration list") from ex
 

homeassistant/components/anglian_water/coordinator.py

@@ -92,7 +92,6 @@ class AnglianWaterUpdateCoordinator(DataUpdateCoordinator[None]):
                 _LOGGER.debug("Updating statistics for the first time")
                 usage_sum = 0.0
                 last_stats_time = None
-                allow_update_last_stored_hour = False
             else:
                 if not meter.readings or len(meter.readings) == 0:
                     _LOGGER.debug("No recent usage statistics found, skipping update")
@@ -108,7 +107,6 @@ class AnglianWaterUpdateCoordinator(DataUpdateCoordinator[None]):
                     continue
                 start = dt_util.as_local(parsed_read_at) - timedelta(hours=1)
                 _LOGGER.debug("Getting statistics at %s", start)
-                stats: dict[str, list[Any]] = {}
                 for end in (start + timedelta(seconds=1), None):
                     stats = await get_instance(self.hass).async_add_executor_job(
                         statistics_during_period,
@@ -129,28 +127,15 @@ class AnglianWaterUpdateCoordinator(DataUpdateCoordinator[None]):
                             "Not found, trying to find oldest statistic after %s",
                             start,
                         )
+                assert stats
 
-                if not stats or not stats.get(usage_statistic_id):
-                    _LOGGER.debug(
-                        "Could not find existing statistics during period lookup for %s, "
-                        "falling back to last stored statistic",
-                        usage_statistic_id,
-                    )
-                    allow_update_last_stored_hour = True
-                    last_records = last_stat[usage_statistic_id]
-                    usage_sum = float(last_records[0].get("sum") or 0.0)
-                    last_stats_time = last_records[0]["start"]
-                else:
-                    allow_update_last_stored_hour = False
-                    records = stats[usage_statistic_id]
+                def _safe_get_sum(records: list[Any]) -> float:
+                    if records and "sum" in records[0]:
+                        return float(records[0]["sum"])
+                    return 0.0
 
-                    def _safe_get_sum(records: list[Any]) -> float:
-                        if records and "sum" in records[0]:
-                            return float(records[0]["sum"])
-                        return 0.0
-
-                    usage_sum = _safe_get_sum(records)
-                    last_stats_time = records[0]["start"]
+                usage_sum = _safe_get_sum(stats.get(usage_statistic_id, []))
+                last_stats_time = stats[usage_statistic_id][0]["start"]
 
             usage_statistics = []
 
@@ -163,13 +148,7 @@ class AnglianWaterUpdateCoordinator(DataUpdateCoordinator[None]):
                     )
                     continue
                 start = dt_util.as_local(parsed_read_at) - timedelta(hours=1)
-                if last_stats_time is not None and (
-                    start.timestamp() < last_stats_time
-                    or (
-                        start.timestamp() == last_stats_time
-                        and not allow_update_last_stored_hour
-                    )
-                ):
+                if last_stats_time is not None and start.timestamp() <= last_stats_time:
                     continue
                 usage_state = max(0, read["consumption"] / 1000)
                 usage_sum = max(0, read["read"])

homeassistant/components/anthropic/__init__.py

@@ -2,25 +2,34 @@
 
 from __future__ import annotations
 
-from anthropic.resources.messages.messages import DEPRECATED_MODELS
+import anthropic
 
-from homeassistant.config_entries import ConfigSubentry
+from homeassistant.config_entries import ConfigEntry, ConfigSubentry
 from homeassistant.const import CONF_API_KEY, Platform
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import (
     config_validation as cv,
     device_registry as dr,
     entity_registry as er,
     issue_registry as ir,
 )
+from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_CHAT_MODEL, DEFAULT_CONVERSATION_NAME, DOMAIN, LOGGER
-from .coordinator import AnthropicConfigEntry, AnthropicCoordinator
+from .const import (
+    CONF_CHAT_MODEL,
+    DEFAULT_CONVERSATION_NAME,
+    DEPRECATED_MODELS,
+    DOMAIN,
+    LOGGER,
+)
 
 PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
+type AnthropicConfigEntry = ConfigEntry[anthropic.AsyncClient]
+
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Anthropic."""
@@ -30,17 +39,38 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
 async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) -> bool:
     """Set up Anthropic from a config entry."""
-    coordinator = AnthropicCoordinator(hass, entry)
-    await coordinator.async_config_entry_first_refresh()
-    entry.runtime_data = coordinator
-    LOGGER.debug("Available models: %s", coordinator.data)
+    client = anthropic.AsyncAnthropic(
+        api_key=entry.data[CONF_API_KEY], http_client=get_async_client(hass)
+    )
+    try:
+        await client.models.list(timeout=10.0)
+    except anthropic.AuthenticationError as err:
+        raise ConfigEntryAuthFailed(
+            translation_domain=DOMAIN,
+            translation_key="api_authentication_error",
+            translation_placeholders={"message": err.message},
+        ) from err
+    except anthropic.AnthropicError as err:
+        raise ConfigEntryNotReady(
+            translation_domain=DOMAIN,
+            translation_key="api_error",
+            translation_placeholders={
+                "message": err.message
+                if isinstance(err, anthropic.APIError)
+                else str(err)
+            },
+        ) from err
+
+    entry.runtime_data = client
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
     entry.async_on_unload(entry.add_update_listener(async_update_options))
 
     for subentry in entry.subentries.values():
-        if (model := subentry.data.get(CONF_CHAT_MODEL)) and model in DEPRECATED_MODELS:
+        if (model := subentry.data.get(CONF_CHAT_MODEL)) and model.startswith(
+            tuple(DEPRECATED_MODELS)
+        ):
             ir.async_create_issue(
                 hass,
                 DOMAIN,
@@ -230,19 +260,6 @@ async def async_migrate_entry(hass: HomeAssistant, entry: AnthropicConfigEntry)
                 )
         hass.config_entries.async_update_entry(entry, minor_version=3)
 
-    if entry.version == 2 and entry.minor_version == 3:
-        # Remove Temperature parameter
-        CONF_TEMPERATURE = "temperature"
-
-        for subentry in entry.subentries.values():
-            data = subentry.data.copy()
-            if CONF_TEMPERATURE not in data:
-                continue
-            data.pop(CONF_TEMPERATURE, None)
-            hass.config_entries.async_update_subentry(entry, subentry, data=data)
-
-        hass.config_entries.async_update_entry(entry, minor_version=4)
-
     LOGGER.debug(
         "Migration to version %s:%s successful", entry.version, entry.minor_version
     )

homeassistant/components/anthropic/config_flow.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from collections.abc import Mapping
 import json
 import logging
+import re
 from typing import TYPE_CHECKING, Any, cast
 
 import anthropic
@@ -29,7 +30,6 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import llm
-import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.httpx_client import get_async_client
 from homeassistant.helpers.selector import (
     NumberSelector,
@@ -43,15 +43,15 @@ from homeassistant.helpers.selector import (
 from homeassistant.helpers.typing import VolDictType
 
 from .const import (
+    CODE_EXECUTION_UNSUPPORTED_MODELS,
     CONF_CHAT_MODEL,
     CONF_CODE_EXECUTION,
     CONF_MAX_TOKENS,
     CONF_PROMPT,
-    CONF_PROMPT_CACHING,
     CONF_RECOMMENDED,
+    CONF_TEMPERATURE,
     CONF_THINKING_BUDGET,
     CONF_THINKING_EFFORT,
-    CONF_TOOL_SEARCH,
     CONF_WEB_SEARCH,
     CONF_WEB_SEARCH_CITY,
     CONF_WEB_SEARCH_COUNTRY,
@@ -63,11 +63,10 @@ from .const import (
     DEFAULT_AI_TASK_NAME,
     DEFAULT_CONVERSATION_NAME,
     DOMAIN,
-    MIN_THINKING_BUDGET,
-    TOOL_SEARCH_UNSUPPORTED_MODELS,
-    PromptCaching,
+    NON_ADAPTIVE_THINKING_MODELS,
+    NON_THINKING_MODELS,
+    WEB_SEARCH_UNSUPPORTED_MODELS,
 )
-from .coordinator import model_alias
 
 if TYPE_CHECKING:
     from . import AnthropicConfigEntry
@@ -102,11 +101,39 @@ async def validate_input(hass: HomeAssistant, data: dict[str, Any]) -> None:
     await client.models.list(timeout=10.0)
 
 
+async def get_model_list(client: anthropic.AsyncAnthropic) -> list[SelectOptionDict]:
+    """Get list of available models."""
+    try:
+        models = (await client.models.list()).data
+    except anthropic.AnthropicError:
+        models = []
+    _LOGGER.debug("Available models: %s", models)
+    model_options: list[SelectOptionDict] = []
+    short_form = re.compile(r"[^\d]-\d$")
+    for model_info in models:
+        # Resolve alias from versioned model name:
+        model_alias = (
+            model_info.id[:-9]
+            if model_info.id != "claude-3-haiku-20240307"
+            and model_info.id[-2:-1] != "-"
+            else model_info.id
+        )
+        if short_form.search(model_alias):
+            model_alias += "-0"
+        model_options.append(
+            SelectOptionDict(
+                label=model_info.display_name,
+                value=model_alias,
+            )
+        )
+    return model_options
+
+
 class AnthropicConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for Anthropic."""
 
     VERSION = 2
-    MINOR_VERSION = 4
+    MINOR_VERSION = 3
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -198,7 +225,6 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
     """Flow for managing conversation subentries."""
 
     options: dict[str, Any]
-    model_info: anthropic.types.ModelInfo
 
     @property
     def _is_new(self) -> bool:
@@ -312,49 +338,29 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
     ) -> SubentryFlowResult:
         """Manage advanced options."""
         errors: dict[str, str] = {}
-        description_placeholders: dict[str, str] = {}
 
         step_schema: VolDictType = {
             vol.Optional(
                 CONF_CHAT_MODEL,
                 default=DEFAULT[CONF_CHAT_MODEL],
-            ): SelectSelector(
-                SelectSelectorConfig(options=self._get_model_list(), custom_value=True)
-            ),
-            vol.Optional(
-                CONF_PROMPT_CACHING,
-                default=DEFAULT[CONF_PROMPT_CACHING],
             ): SelectSelector(
                 SelectSelectorConfig(
-                    options=[x.value for x in PromptCaching],
-                    translation_key=CONF_PROMPT_CACHING,
-                    mode=SelectSelectorMode.DROPDOWN,
+                    options=await self._get_model_list(), custom_value=True
                 )
             ),
+            vol.Optional(
+                CONF_MAX_TOKENS,
+                default=DEFAULT[CONF_MAX_TOKENS],
+            ): int,
+            vol.Optional(
+                CONF_TEMPERATURE,
+                default=DEFAULT[CONF_TEMPERATURE],
+            ): NumberSelector(NumberSelectorConfig(min=0, max=1, step=0.05)),
         }
 
         if user_input is not None:
             self.options.update(user_input)
 
-            coordinator = self._get_entry().runtime_data
-            self.model_info, status = coordinator.get_model_info(
-                self.options[CONF_CHAT_MODEL]
-            )
-            if not status:
-                # Couldn't find the model in the cached list, try to fetch it directly
-                client = coordinator.client
-                try:
-                    self.model_info = await client.models.retrieve(
-                        self.options[CONF_CHAT_MODEL], timeout=10.0
-                    )
-                except anthropic.NotFoundError:
-                    errors[CONF_CHAT_MODEL] = "model_not_found"
-                except anthropic.AnthropicError as err:
-                    errors[CONF_CHAT_MODEL] = "api_error"
-                    description_placeholders["message"] = (
-                        err.message if isinstance(err, anthropic.APIError) else str(err)
-                    )
-
             if not errors:
                 return await self.async_step_model()
 
@@ -364,7 +370,6 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
                 vol.Schema(step_schema), self.options
             ),
             errors=errors,
-            description_placeholders=description_placeholders,
         )
 
     async def async_step_model(
@@ -373,59 +378,30 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
         """Manage model-specific options."""
         errors: dict[str, str] = {}
 
-        step_schema: VolDictType = {
-            vol.Optional(
-                CONF_MAX_TOKENS,
-                default=DEFAULT[CONF_MAX_TOKENS],
-            ): vol.All(
-                NumberSelector(
-                    NumberSelectorConfig(min=0, max=self.model_info.max_tokens)
-                ),
-                vol.Coerce(int),
-            )
-            if self.model_info.max_tokens
-            else cv.positive_int,
-        }
+        step_schema: VolDictType = {}
 
-        if (
-            self.model_info.capabilities
-            and self.model_info.capabilities.thinking.supported
-            and not self.model_info.capabilities.thinking.types.adaptive.supported
+        model = self.options[CONF_CHAT_MODEL]
+
+        if not model.startswith(tuple(NON_THINKING_MODELS)) and model.startswith(
+            tuple(NON_ADAPTIVE_THINKING_MODELS)
         ):
             step_schema[
                 vol.Optional(
                     CONF_THINKING_BUDGET, default=DEFAULT[CONF_THINKING_BUDGET]
                 )
-            ] = (
-                vol.All(
-                    NumberSelector(
-                        NumberSelectorConfig(min=0, max=self.model_info.max_tokens)
-                    ),
-                    vol.Coerce(int),
-                )
-                if self.model_info.max_tokens
-                else cv.positive_int
+            ] = vol.All(
+                NumberSelector(
+                    NumberSelectorConfig(
+                        min=0,
+                        max=self.options.get(CONF_MAX_TOKENS, DEFAULT[CONF_MAX_TOKENS]),
+                    )
+                ),
+                vol.Coerce(int),
             )
         else:
             self.options.pop(CONF_THINKING_BUDGET, None)
 
-        if (
-            self.model_info.capabilities
-            and (effort_capability := self.model_info.capabilities.effort).supported
-        ):
-            effort_options: list[str] = []
-            if self.model_info.capabilities.thinking.types.adaptive.supported:
-                effort_options.append("none")
-            if effort_capability.low.supported:
-                effort_options.append("low")
-            if effort_capability.medium.supported:
-                effort_options.append("medium")
-            if effort_capability.high.supported:
-                effort_options.append("high")
-            if effort_capability.xhigh and effort_capability.xhigh.supported:
-                effort_options.append("xhigh")
-            if effort_capability.max.supported:
-                effort_options.append("max")
+        if not model.startswith(tuple(NON_ADAPTIVE_THINKING_MODELS)):
             step_schema[
                 vol.Optional(
                     CONF_THINKING_EFFORT,
@@ -433,7 +409,7 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
                 )
             ] = SelectSelector(
                 SelectSelectorConfig(
-                    options=effort_options,
+                    options=["none", "low", "medium", "high", "max"],
                     translation_key=CONF_THINKING_EFFORT,
                     mode=SelectSelectorMode.DROPDOWN,
                 )
@@ -441,58 +417,47 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
         else:
             self.options.pop(CONF_THINKING_EFFORT, None)
 
-        step_schema.update(
-            {
+        if not model.startswith(tuple(CODE_EXECUTION_UNSUPPORTED_MODELS)):
+            step_schema[
                 vol.Optional(
                     CONF_CODE_EXECUTION,
                     default=DEFAULT[CONF_CODE_EXECUTION],
-                ): bool,
-                vol.Optional(
-                    CONF_WEB_SEARCH,
-                    default=DEFAULT[CONF_WEB_SEARCH],
-                ): bool,
-                vol.Optional(
-                    CONF_WEB_SEARCH_MAX_USES,
-                    default=DEFAULT[CONF_WEB_SEARCH_MAX_USES],
-                ): int,
-                vol.Optional(
-                    CONF_WEB_SEARCH_USER_LOCATION,
-                    default=DEFAULT[CONF_WEB_SEARCH_USER_LOCATION],
-                ): bool,
-            }
-        )
+                )
+            ] = bool
+        else:
+            self.options.pop(CONF_CODE_EXECUTION, None)
+
+        if not model.startswith(tuple(WEB_SEARCH_UNSUPPORTED_MODELS)):
+            step_schema.update(
+                {
+                    vol.Optional(
+                        CONF_WEB_SEARCH,
+                        default=DEFAULT[CONF_WEB_SEARCH],
+                    ): bool,
+                    vol.Optional(
+                        CONF_WEB_SEARCH_MAX_USES,
+                        default=DEFAULT[CONF_WEB_SEARCH_MAX_USES],
+                    ): int,
+                    vol.Optional(
+                        CONF_WEB_SEARCH_USER_LOCATION,
+                        default=DEFAULT[CONF_WEB_SEARCH_USER_LOCATION],
+                    ): bool,
+                }
+            )
+        else:
+            self.options.pop(CONF_WEB_SEARCH, None)
+            self.options.pop(CONF_WEB_SEARCH_MAX_USES, None)
+            self.options.pop(CONF_WEB_SEARCH_USER_LOCATION, None)
 
         self.options.pop(CONF_WEB_SEARCH_CITY, None)
         self.options.pop(CONF_WEB_SEARCH_REGION, None)
         self.options.pop(CONF_WEB_SEARCH_COUNTRY, None)
         self.options.pop(CONF_WEB_SEARCH_TIMEZONE, None)
 
-        model = self.options[CONF_CHAT_MODEL]
-
-        if not model.startswith(tuple(TOOL_SEARCH_UNSUPPORTED_MODELS)):
-            step_schema[
-                vol.Optional(
-                    CONF_TOOL_SEARCH,
-                    default=DEFAULT[CONF_TOOL_SEARCH],
-                )
-            ] = bool
-        else:
-            self.options.pop(CONF_TOOL_SEARCH, None)
-
         if not step_schema:
-            # Currently our schema is always present, but if one day it becomes empty,
-            # then the below line is needed to skip this step
-            user_input = {}  # pragma: no cover
+            user_input = {}
 
         if user_input is not None:
-            if (
-                CONF_THINKING_BUDGET in user_input
-                and user_input[CONF_THINKING_BUDGET] >= MIN_THINKING_BUDGET
-                and user_input[CONF_THINKING_BUDGET]
-                >= user_input.get(CONF_MAX_TOKENS, DEFAULT[CONF_MAX_TOKENS])
-            ):
-                errors[CONF_THINKING_BUDGET] = "thinking_budget_too_large"
-
             if user_input.get(CONF_WEB_SEARCH, DEFAULT[CONF_WEB_SEARCH]) and not errors:
                 if user_input.get(
                     CONF_WEB_SEARCH_USER_LOCATION,
@@ -524,16 +489,13 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
             last_step=True,
         )
 
-    def _get_model_list(self) -> list[SelectOptionDict]:
+    async def _get_model_list(self) -> list[SelectOptionDict]:
         """Get list of available models."""
-        coordinator = self._get_entry().runtime_data
-        return [
-            SelectOptionDict(
-                label=model_info.display_name,
-                value=model_alias(model_info.id),
-            )
-            for model_info in coordinator.data or []
-        ]
+        client = anthropic.AsyncAnthropic(
+            api_key=self._get_entry().data[CONF_API_KEY],
+            http_client=get_async_client(self.hass),
+        )
+        return await get_model_list(client)
 
     async def _get_location_data(self) -> dict[str, str]:
         """Get approximate location data of the user."""

homeassistant/components/anthropic/const.py

@@ -1,6 +1,5 @@
 """Constants for the Anthropic integration."""
 
-from enum import StrEnum
 import logging
 
 DOMAIN = "anthropic"
@@ -14,10 +13,9 @@ CONF_PROMPT = "prompt"
 CONF_CHAT_MODEL = "chat_model"
 CONF_CODE_EXECUTION = "code_execution"
 CONF_MAX_TOKENS = "max_tokens"
-CONF_PROMPT_CACHING = "prompt_caching"
+CONF_TEMPERATURE = "temperature"
 CONF_THINKING_BUDGET = "thinking_budget"
 CONF_THINKING_EFFORT = "thinking_effort"
-CONF_TOOL_SEARCH = "tool_search"
 CONF_WEB_SEARCH = "web_search"
 CONF_WEB_SEARCH_USER_LOCATION = "user_location"
 CONF_WEB_SEARCH_MAX_USES = "web_search_max_uses"
@@ -26,30 +24,53 @@ CONF_WEB_SEARCH_REGION = "region"
 CONF_WEB_SEARCH_COUNTRY = "country"
 CONF_WEB_SEARCH_TIMEZONE = "timezone"
 
-
-class PromptCaching(StrEnum):
-    """Prompt caching options."""
-
-    OFF = "off"
-    PROMPT = "prompt"
-    AUTOMATIC = "automatic"
-
-
-MIN_THINKING_BUDGET = 1024
-
 DEFAULT = {
     CONF_CHAT_MODEL: "claude-haiku-4-5",
     CONF_CODE_EXECUTION: False,
     CONF_MAX_TOKENS: 3000,
-    CONF_PROMPT_CACHING: PromptCaching.PROMPT.value,
-    CONF_THINKING_BUDGET: MIN_THINKING_BUDGET,
+    CONF_TEMPERATURE: 1.0,
+    CONF_THINKING_BUDGET: 0,
     CONF_THINKING_EFFORT: "low",
-    CONF_TOOL_SEARCH: False,
     CONF_WEB_SEARCH: False,
     CONF_WEB_SEARCH_USER_LOCATION: False,
     CONF_WEB_SEARCH_MAX_USES: 5,
 }
 
-TOOL_SEARCH_UNSUPPORTED_MODELS = [
-    "claude-haiku",
+MIN_THINKING_BUDGET = 1024
+
+NON_THINKING_MODELS = [
+    "claude-3-haiku",
+]
+
+NON_ADAPTIVE_THINKING_MODELS = [
+    "claude-opus-4-5",
+    "claude-sonnet-4-5",
+    "claude-haiku-4-5",
+    "claude-opus-4-1",
+    "claude-opus-4-0",
+    "claude-opus-4-20250514",
+    "claude-sonnet-4-0",
+    "claude-sonnet-4-20250514",
+    "claude-3-haiku",
+]
+
+UNSUPPORTED_STRUCTURED_OUTPUT_MODELS = [
+    "claude-opus-4-1",
+    "claude-opus-4-0",
+    "claude-opus-4-20250514",
+    "claude-sonnet-4-0",
+    "claude-sonnet-4-20250514",
+    "claude-3-haiku",
+]
+
+WEB_SEARCH_UNSUPPORTED_MODELS = [
+    "claude-3-haiku",
+]
+
+CODE_EXECUTION_UNSUPPORTED_MODELS = [
+    "claude-3-haiku",
+]
+
+DEPRECATED_MODELS = [
+    "claude-3",
 ]

homeassistant/components/anthropic/coordinator.py

@@ -1,113 +0,0 @@
-"""Coordinator for the Anthropic integration."""
-
-from __future__ import annotations
-
-import datetime
-import re
-
-import anthropic
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_API_KEY
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from homeassistant.helpers.httpx_client import get_async_client
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
-
-from .const import DOMAIN, LOGGER
-
-UPDATE_INTERVAL_CONNECTED = datetime.timedelta(hours=12)
-UPDATE_INTERVAL_DISCONNECTED = datetime.timedelta(minutes=1)
-
-type AnthropicConfigEntry = ConfigEntry[AnthropicCoordinator]
-
-
-_model_short_form = re.compile(r"[^\d]-\d$")
-
-
-@callback
-def model_alias(model_id: str) -> str:
-    """Resolve alias from versioned model name."""
-    if model_id[-2:-1] != "-" and not model_id.endswith("-preview"):
-        model_id = model_id[:-9]
-    if _model_short_form.search(model_id):
-        return model_id + "-0"
-    return model_id
-
-
-class AnthropicCoordinator(DataUpdateCoordinator[list[anthropic.types.ModelInfo]]):
-    """DataUpdateCoordinator which uses different intervals after successful and unsuccessful updates."""
-
-    client: anthropic.AsyncAnthropic
-
-    def __init__(self, hass: HomeAssistant, config_entry: AnthropicConfigEntry) -> None:
-        """Initialize the coordinator."""
-        super().__init__(
-            hass,
-            LOGGER,
-            config_entry=config_entry,
-            name=config_entry.title,
-            update_interval=UPDATE_INTERVAL_CONNECTED,
-            update_method=self.async_update_data,
-            always_update=False,
-        )
-        self.client = anthropic.AsyncAnthropic(
-            api_key=config_entry.data[CONF_API_KEY], http_client=get_async_client(hass)
-        )
-
-    @callback
-    def async_set_updated_data(self, data: list[anthropic.types.ModelInfo]) -> None:
-        """Manually update data, notify listeners and update refresh interval."""
-        self.update_interval = UPDATE_INTERVAL_CONNECTED
-        super().async_set_updated_data(data)
-
-    async def async_update_data(self) -> list[anthropic.types.ModelInfo]:
-        """Fetch data from the API."""
-        try:
-            self.update_interval = UPDATE_INTERVAL_DISCONNECTED
-            result = await self.client.models.list(timeout=10.0)
-            self.update_interval = UPDATE_INTERVAL_CONNECTED
-        except anthropic.APITimeoutError as err:
-            raise TimeoutError(err.message or str(err)) from err
-        except anthropic.AuthenticationError as err:
-            raise ConfigEntryAuthFailed(
-                translation_domain=DOMAIN,
-                translation_key="api_authentication_error",
-                translation_placeholders={"message": err.message},
-            ) from err
-        except anthropic.APIError as err:
-            raise UpdateFailed(
-                translation_domain=DOMAIN,
-                translation_key="api_error",
-                translation_placeholders={"message": err.message},
-            ) from err
-        return result.data
-
-    def mark_connection_error(self) -> None:
-        """Mark the connection as having an error and reschedule background check."""
-        self.update_interval = UPDATE_INTERVAL_DISCONNECTED
-        if self.last_update_success:
-            self.last_update_success = False
-            self.async_update_listeners()
-            if self._listeners and not self.hass.is_stopping:
-                self._schedule_refresh()
-
-    @callback
-    def get_model_info(self, model_id: str) -> tuple[anthropic.types.ModelInfo, bool]:
-        """Get model info for a given model ID."""
-        # First try: exact name match
-        for model in self.data or []:
-            if model.id == model_id:
-                return model, True
-        # Second try: match by alias
-        alias = model_alias(model_id)
-        for model in self.data or []:
-            if model_alias(model.id) == alias:
-                return model, True
-        # Model not found, return safe defaults
-        return anthropic.types.ModelInfo(
-            type="model",
-            id=model_id,
-            created_at=datetime.datetime(1970, 1, 1, tzinfo=datetime.UTC),
-            display_name=alias,
-        ), False