Add AI Task prefs

* use entityDescription

* Add new event and adapt tests

* change translation

* use references in strings

.github/workflows/builder.yml

@@ -94,7 +94,7 @@ jobs:
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@v9
+        uses: dawidd6/action-download-artifact@v10
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -105,7 +105,7 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@v9
+        uses: dawidd6/action-download-artifact@v10
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/intents-package
@@ -509,7 +509,7 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Build Docker image
-        uses: docker/build-push-action@14487ce63c7a62a4a324b0bfb37086795e31c6c1 # v6.16.0
+        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
         with:
           context: . # So action will not pull the repository again
           file: ./script/hassfest/docker/Dockerfile
@@ -522,7 +522,7 @@ jobs:
       - name: Push Docker image
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
         id: push
-        uses: docker/build-push-action@14487ce63c7a62a4a324b0bfb37086795e31c6c1 # v6.16.0
+        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
         with:
           context: . # So action will not pull the repository again
           file: ./script/hassfest/docker/Dockerfile
@@ -531,7 +531,7 @@ jobs:
 
       - name: Generate artifact attestation
         if: needs.init.outputs.channel != 'dev' && needs.init.outputs.publish == 'true'
-        uses: actions/attest-build-provenance@db473fddc028af60658334401dc6fa3ffd8669fd # v2.3.0
+        uses: actions/attest-build-provenance@e8998f949152b193b063cb0ec769d69d929409be # v2.4.0
         with:
           subject-name: ${{ env.HASSFEST_IMAGE_NAME }}
           subject-digest: ${{ steps.push.outputs.digest }}

.github/workflows/ci.yaml

@@ -40,7 +40,7 @@ env:
   CACHE_VERSION: 2
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2025.6"
+  HA_SHORT_VERSION: "2025.7"
   DEFAULT_PYTHON: "3.13"
   ALL_PYTHON_VERSIONS: "['3.13']"
   # 10.3 is the oldest supported version
@@ -360,7 +360,7 @@ jobs:
       - name: Run ruff
         run: |
           . venv/bin/activate
-          pre-commit run --hook-stage manual ruff --all-files --show-diff-on-failure
+          pre-commit run --hook-stage manual ruff-check --all-files --show-diff-on-failure
         env:
           RUFF_OUTPUT_FORMAT: github
 
@@ -653,7 +653,7 @@ jobs:
       - name: Check out code from GitHub
         uses: actions/checkout@v4.2.2
       - name: Dependency review
-        uses: actions/dependency-review-action@v4.7.0
+        uses: actions/dependency-review-action@v4.7.1
         with:
           license-check: false # We use our own license audit checks
 
@@ -944,7 +944,8 @@ jobs:
             bluez \
             ffmpeg \
             libturbojpeg \
-            libgammu-dev
+            libgammu-dev \
+            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@v4.2.2
       - name: Set up Python ${{ matrix.python-version }}
@@ -1020,6 +1021,12 @@ jobs:
           name: coverage-${{ matrix.python-version }}-${{ matrix.group }}
           path: coverage.xml
           overwrite: true
+      - name: Beautify test results
+        # For easier identification of parsing errors
+        if: needs.info.outputs.skip_coverage != 'true'
+        run: |
+          xmllint --format "junit.xml" > "junit.xml-tmp"
+          mv "junit.xml-tmp" "junit.xml"
       - name: Upload test results artifact
         if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
         uses: actions/upload-artifact@v4.6.2
@@ -1070,7 +1077,8 @@ jobs:
             bluez \
             ffmpeg \
             libturbojpeg \
-            libmariadb-dev-compat
+            libmariadb-dev-compat \
+            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@v4.2.2
       - name: Set up Python ${{ matrix.python-version }}
@@ -1154,6 +1162,12 @@ jobs:
             steps.pytest-partial.outputs.mariadb }}
           path: coverage.xml
           overwrite: true
+      - name: Beautify test results
+        # For easier identification of parsing errors
+        if: needs.info.outputs.skip_coverage != 'true'
+        run: |
+          xmllint --format "junit.xml" > "junit.xml-tmp"
+          mv "junit.xml-tmp" "junit.xml"
       - name: Upload test results artifact
         if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
         uses: actions/upload-artifact@v4.6.2
@@ -1202,7 +1216,8 @@ jobs:
           sudo apt-get -y install \
             bluez \
             ffmpeg \
-            libturbojpeg
+            libturbojpeg \
+            libxml2-utils
           sudo /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y
           sudo apt-get -y install \
             postgresql-server-dev-14
@@ -1290,6 +1305,12 @@ jobs:
             steps.pytest-partial.outputs.postgresql }}
           path: coverage.xml
           overwrite: true
+      - name: Beautify test results
+        # For easier identification of parsing errors
+        if: needs.info.outputs.skip_coverage != 'true'
+        run: |
+          xmllint --format "junit.xml" > "junit.xml-tmp"
+          mv "junit.xml-tmp" "junit.xml"
       - name: Upload test results artifact
         if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
         uses: actions/upload-artifact@v4.6.2
@@ -1320,7 +1341,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'true'
-        uses: codecov/codecov-action@v5.4.2
+        uses: codecov/codecov-action@v5.4.3
         with:
           fail_ci_if_error: true
           flags: full-suite
@@ -1357,7 +1378,8 @@ jobs:
             bluez \
             ffmpeg \
             libturbojpeg \
-            libgammu-dev
+            libgammu-dev \
+            libxml2-utils
       - name: Check out code from GitHub
         uses: actions/checkout@v4.2.2
       - name: Set up Python ${{ matrix.python-version }}
@@ -1436,6 +1458,12 @@ jobs:
           name: coverage-${{ matrix.python-version }}-${{ matrix.group }}
           path: coverage.xml
           overwrite: true
+      - name: Beautify test results
+        # For easier identification of parsing errors
+        if: needs.info.outputs.skip_coverage != 'true'
+        run: |
+          xmllint --format "junit.xml" > "junit.xml-tmp"
+          mv "junit.xml-tmp" "junit.xml"
       - name: Upload test results artifact
         if: needs.info.outputs.skip_coverage != 'true' && !cancelled()
         uses: actions/upload-artifact@v4.6.2
@@ -1463,7 +1491,7 @@ jobs:
           pattern: coverage-*
       - name: Upload coverage to Codecov
         if: needs.info.outputs.test_full_suite == 'false'
-        uses: codecov/codecov-action@v5.4.2
+        uses: codecov/codecov-action@v5.4.3
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/codeql.yml

@@ -24,11 +24,11 @@ jobs:
         uses: actions/checkout@v4.2.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v3.28.17
+        uses: github/codeql-action/init@v3.29.0
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v3.28.17
+        uses: github/codeql-action/analyze@v3.29.0
         with:
           category: "/language:python"

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

@@ -0,0 +1,385 @@
+name: Auto-detect duplicate issues
+
+# yamllint disable-line rule:truthy
+on:
+  issues:
+    types: [labeled]
+
+permissions:
+  issues: write
+  models: read
+
+jobs:
+  detect-duplicates:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check if integration label was added and extract details
+        id: extract
+        uses: actions/github-script@v7.0.1
+        with:
+          script: |
+            // Debug: Log the event payload
+            console.log('Event name:', context.eventName);
+            console.log('Event action:', context.payload.action);
+            console.log('Event payload keys:', Object.keys(context.payload));
+
+            // Check the specific label that was added
+            const addedLabel = context.payload.label;
+            if (!addedLabel) {
+              console.log('No label found in labeled event payload');
+              core.setOutput('should_continue', 'false');
+              return;
+            }
+
+            console.log(`Label added: ${addedLabel.name}`);
+
+            if (!addedLabel.name.startsWith('integration:')) {
+              console.log('Added label is not an integration label, skipping duplicate detection');
+              core.setOutput('should_continue', 'false');
+              return;
+            }
+
+            console.log(`Integration label added: ${addedLabel.name}`);
+
+            let currentIssue;
+            let integrationLabels = [];
+
+            try {
+              const issue = await github.rest.issues.get({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.issue.number
+              });
+
+              currentIssue = issue.data;
+
+              // Check if potential-duplicate label already exists
+              const hasPotentialDuplicateLabel = currentIssue.labels
+                .some(label => label.name === 'potential-duplicate');
+
+              if (hasPotentialDuplicateLabel) {
+                console.log('Issue already has potential-duplicate label, skipping duplicate detection');
+                core.setOutput('should_continue', 'false');
+                return;
+              }
+
+              integrationLabels = currentIssue.labels
+                .filter(label => label.name.startsWith('integration:'))
+                .map(label => label.name);
+            } catch (error) {
+              core.error(`Failed to fetch issue #${context.payload.issue.number}:`, error.message);
+              core.setOutput('should_continue', 'false');
+              return;
+            }
+
+            // Check if we've already posted a duplicate detection comment recently
+            let comments;
+            try {
+              comments = await github.rest.issues.listComments({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.issue.number,
+                per_page: 10
+              });
+            } catch (error) {
+              core.error('Failed to fetch comments:', error.message);
+              // Continue anyway, worst case we might post a duplicate comment
+              comments = { data: [] };
+            }
+
+            // Check if we've already posted a duplicate detection comment
+            const recentDuplicateComment = comments.data.find(comment =>
+              comment.user && comment.user.login === 'github-actions[bot]' &&
+              comment.body.includes('<!-- workflow: detect-duplicate-issues -->')
+            );
+
+            if (recentDuplicateComment) {
+              console.log('Already posted duplicate detection comment, skipping');
+              core.setOutput('should_continue', 'false');
+              return;
+            }
+
+            core.setOutput('should_continue', 'true');
+            core.setOutput('current_number', currentIssue.number);
+            core.setOutput('current_title', currentIssue.title);
+            core.setOutput('current_body', currentIssue.body);
+            core.setOutput('current_url', currentIssue.html_url);
+            core.setOutput('integration_labels', JSON.stringify(integrationLabels));
+
+            console.log(`Current issue: #${currentIssue.number}`);
+            console.log(`Integration labels: ${integrationLabels.join(', ')}`);
+
+      - name: Fetch similar issues
+        id: fetch_similar
+        if: steps.extract.outputs.should_continue == 'true'
+        uses: actions/github-script@v7.0.1
+        env:
+          INTEGRATION_LABELS: ${{ steps.extract.outputs.integration_labels }}
+          CURRENT_NUMBER: ${{ steps.extract.outputs.current_number }}
+        with:
+          script: |
+            const integrationLabels = JSON.parse(process.env.INTEGRATION_LABELS);
+            const currentNumber = parseInt(process.env.CURRENT_NUMBER);
+
+            if (integrationLabels.length === 0) {
+              console.log('No integration labels found, skipping duplicate detection');
+              core.setOutput('has_similar', 'false');
+              return;
+            }
+
+            // Use GitHub search API to find issues with matching integration labels
+            console.log(`Searching for issues with integration labels: ${integrationLabels.join(', ')}`);
+
+            // Build search query for issues with any of the current integration labels
+            const labelQueries = integrationLabels.map(label => `label:"${label}"`);
+
+            // Calculate date 6 months ago
+            const sixMonthsAgo = new Date();
+            sixMonthsAgo.setMonth(sixMonthsAgo.getMonth() - 6);
+            const dateFilter = `created:>=${sixMonthsAgo.toISOString().split('T')[0]}`;
+
+            let searchQuery;
+
+            if (labelQueries.length === 1) {
+              searchQuery = `repo:${context.repo.owner}/${context.repo.repo} is:issue ${labelQueries[0]} ${dateFilter}`;
+            } else {
+              searchQuery = `repo:${context.repo.owner}/${context.repo.repo} is:issue (${labelQueries.join(' OR ')}) ${dateFilter}`;
+            }
+
+            console.log(`Search query: ${searchQuery}`);
+
+            let result;
+            try {
+              result = await github.rest.search.issuesAndPullRequests({
+                q: searchQuery,
+                per_page: 15,
+                sort: 'updated',
+                order: 'desc'
+              });
+            } catch (error) {
+              core.error('Failed to search for similar issues:', error.message);
+              if (error.status === 403 && error.message.includes('rate limit')) {
+                core.error('GitHub API rate limit exceeded');
+              }
+              core.setOutput('has_similar', 'false');
+              return;
+            }
+
+            // Filter out the current issue, pull requests, and newer issues (higher numbers)
+            const similarIssues = result.data.items
+              .filter(item =>
+                item.number !== currentNumber &&
+                !item.pull_request &&
+                item.number < currentNumber // Only include older issues (lower numbers)
+              )
+              .map(item => ({
+                number: item.number,
+                title: item.title,
+                body: item.body,
+                url: item.html_url,
+                state: item.state,
+                createdAt: item.created_at,
+                updatedAt: item.updated_at,
+                comments: item.comments,
+                labels: item.labels.map(l => l.name)
+              }));
+
+            console.log(`Found ${similarIssues.length} issues with matching integration labels`);
+            console.log('Raw similar issues:', JSON.stringify(similarIssues.slice(0, 3), null, 2));
+
+            if (similarIssues.length === 0) {
+              console.log('No similar issues found, setting has_similar to false');
+              core.setOutput('has_similar', 'false');
+              return;
+            }
+
+            console.log('Similar issues found, setting has_similar to true');
+            core.setOutput('has_similar', 'true');
+
+            // Clean the issue data to prevent JSON parsing issues
+            const cleanedIssues = similarIssues.slice(0, 15).map(item => {
+              // Handle body with improved truncation and null handling
+              let cleanBody = '';
+              if (item.body && typeof item.body === 'string') {
+                // Remove control characters
+                const cleaned = item.body.replace(/[\u0000-\u001F\u007F-\u009F]/g, '');
+                // Truncate to 1000 characters and add ellipsis if needed
+                cleanBody = cleaned.length > 1000
+                  ? cleaned.substring(0, 1000) + '...'
+                  : cleaned;
+              }
+
+              return {
+                number: item.number,
+                title: item.title.replace(/[\u0000-\u001F\u007F-\u009F]/g, ''), // Remove control characters
+                body: cleanBody,
+                url: item.url,
+                state: item.state,
+                createdAt: item.createdAt,
+                updatedAt: item.updatedAt,
+                comments: item.comments,
+                labels: item.labels
+              };
+            });
+
+            console.log(`Cleaned issues count: ${cleanedIssues.length}`);
+            console.log('First cleaned issue:', JSON.stringify(cleanedIssues[0], null, 2));
+
+            core.setOutput('similar_issues', JSON.stringify(cleanedIssues));
+
+      - name: Detect duplicates using AI
+        id: ai_detection
+        if: steps.extract.outputs.should_continue == 'true' && steps.fetch_similar.outputs.has_similar == 'true'
+        uses: actions/ai-inference@v1.1.0
+        with:
+          model: openai/gpt-4o
+          system-prompt: |
+            You are a Home Assistant issue duplicate detector. Your task is to identify TRUE DUPLICATES - issues that report the EXACT SAME problem, not just similar or related issues.
+
+            CRITICAL: An issue is ONLY a duplicate if:
+            - It describes the SAME problem with the SAME root cause
+            - Issues about the same integration but different problems are NOT duplicates
+            - Issues with similar symptoms but different causes are NOT duplicates
+
+            Important considerations:
+            - Open issues are more relevant than closed ones for duplicate detection
+            - Recently updated issues may indicate ongoing work or discussion
+            - Issues with more comments are generally more relevant and active
+            - Older closed issues might be resolved differently than newer approaches
+            - Consider the time between issues - very old issues may have different contexts
+
+            Rules:
+            1. ONLY mark as duplicate if the issues describe IDENTICAL problems
+            2. Look for issues that report the same problem or request the same functionality
+            3. Different error messages = NOT a duplicate (even if same integration)
+            4. For CLOSED issues, only mark as duplicate if they describe the EXACT same problem
+            5. For OPEN issues, use a lower threshold (90%+ similarity)
+            6. Prioritize issues with higher comment counts as they indicate more activity/relevance
+            7. When in doubt, do NOT mark as duplicate
+            8. Return ONLY a JSON array of issue numbers that are duplicates
+            9. If no duplicates are found, return an empty array: []
+            10. Maximum 5 potential duplicates, prioritize open issues with comments
+            11. Consider the age of issues - prefer recent duplicates over very old ones
+
+            Example response format:
+            [1234, 5678, 9012]
+
+          prompt: |
+            Current issue (just created):
+            Title: ${{ steps.extract.outputs.current_title }}
+            Body: ${{ steps.extract.outputs.current_body }}
+
+            Other issues to compare against (each includes state, creation date, last update, and comment count):
+            ${{ steps.fetch_similar.outputs.similar_issues }}
+
+            Analyze these issues and identify which ones describe IDENTICAL problems and thus are duplicates of the current issue. When sorting them, consider their state (open/closed), how recently they were updated, and their comment count (higher = more relevant).
+
+          max-tokens: 100
+
+      - 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@v7.0.1
+        env:
+          AI_RESPONSE: ${{ steps.ai_detection.outputs.response }}
+          SIMILAR_ISSUES: ${{ steps.fetch_similar.outputs.similar_issues }}
+        with:
+          script: |
+            const aiResponse = process.env.AI_RESPONSE;
+
+            console.log('Raw AI response:', JSON.stringify(aiResponse));
+
+            let duplicateNumbers = [];
+            try {
+              // Clean the response of any potential control characters
+              const cleanResponse = aiResponse.trim().replace(/[\u0000-\u001F\u007F-\u009F]/g, '');
+              console.log('Cleaned AI response:', cleanResponse);
+
+              duplicateNumbers = JSON.parse(cleanResponse);
+
+              // Ensure it's an array and contains only numbers
+              if (!Array.isArray(duplicateNumbers)) {
+                console.log('AI response is not an array, trying to extract numbers');
+                const numberMatches = cleanResponse.match(/\d+/g);
+                duplicateNumbers = numberMatches ? numberMatches.map(n => parseInt(n)) : [];
+              }
+
+              // Filter to only valid numbers
+              duplicateNumbers = duplicateNumbers.filter(n => typeof n === 'number' && !isNaN(n));
+
+            } catch (error) {
+              console.log('Failed to parse AI response as JSON:', error.message);
+              console.log('Raw response:', aiResponse);
+
+              // Fallback: try to extract numbers from the response
+              const numberMatches = aiResponse.match(/\d+/g);
+              duplicateNumbers = numberMatches ? numberMatches.map(n => parseInt(n)) : [];
+              console.log('Extracted numbers as fallback:', duplicateNumbers);
+            }
+
+            if (!Array.isArray(duplicateNumbers) || duplicateNumbers.length === 0) {
+              console.log('No duplicates detected by AI');
+              return;
+            }
+
+            console.log(`AI detected ${duplicateNumbers.length} potential duplicates: ${duplicateNumbers.join(', ')}`);
+
+            // Get details of detected duplicates
+            const similarIssues = JSON.parse(process.env.SIMILAR_ISSUES);
+            const duplicates = similarIssues.filter(issue => duplicateNumbers.includes(issue.number));
+
+            if (duplicates.length === 0) {
+              console.log('No matching issues found for detected numbers');
+              return;
+            }
+
+            // Create comment with duplicate detection results
+            const duplicateLinks = duplicates.map(issue => `- [#${issue.number}: ${issue.title}](${issue.url})`).join('\n');
+
+            const commentBody = [
+              '<!-- workflow: detect-duplicate-issues -->',
+              '### 🔍 **Potential duplicate detection**',
+              '',
+              'I\'ve analyzed similar issues and found the following potential duplicates:',
+              '',
+              duplicateLinks,
+              '',
+              '**What to do next:**',
+              '1. Please review these issues to see if they match your issue',
+              '2. If you find an existing issue that covers your problem:',
+              '   - Consider closing this issue',
+              '   - Add your findings or 👍 on the existing issue instead',
+              '3. If your issue is different or adds new aspects, please clarify how it differs',
+              '',
+              'This helps keep our issues organized and ensures similar issues are consolidated for better visibility.',
+              '',
+              '*This message was generated automatically by our duplicate detection system.*'
+            ].join('\n');
+
+            try {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.issue.number,
+                body: commentBody
+              });
+
+              console.log(`Posted duplicate detection comment with ${duplicates.length} potential duplicates`);
+
+              // Add the potential-duplicate label
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: context.payload.issue.number,
+                labels: ['potential-duplicate']
+              });
+
+              console.log('Added potential-duplicate label to the issue');
+            } catch (error) {
+              core.error('Failed to post duplicate detection comment or add label:', error.message);
+              if (error.status === 403) {
+                core.error('Permission denied or rate limit exceeded');
+              }
+              // Don't throw - we've done the analysis, just couldn't post the result
+            }

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

@@ -0,0 +1,193 @@
+name: Auto-detect non-English issues
+
+# yamllint disable-line rule:truthy
+on:
+  issues:
+    types: [opened]
+
+permissions:
+  issues: write
+  models: read
+
+jobs:
+  detect-language:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check issue language
+        id: detect_language
+        uses: actions/github-script@v7.0.1
+        env:
+          ISSUE_NUMBER: ${{ github.event.issue.number }}
+          ISSUE_TITLE: ${{ github.event.issue.title }}
+          ISSUE_BODY: ${{ github.event.issue.body }}
+          ISSUE_USER_TYPE: ${{ github.event.issue.user.type }}
+        with:
+          script: |
+            // Get the issue details from environment variables
+            const issueNumber = process.env.ISSUE_NUMBER;
+            const issueTitle = process.env.ISSUE_TITLE || '';
+            const issueBody = process.env.ISSUE_BODY || '';
+            const userType = process.env.ISSUE_USER_TYPE;
+
+            // Skip language detection for bot users
+            if (userType === 'Bot') {
+              console.log('Skipping language detection for bot user');
+              core.setOutput('should_continue', 'false');
+              return;
+            }
+
+            console.log(`Checking language for issue #${issueNumber}`);
+            console.log(`Title: ${issueTitle}`);
+
+            // Combine title and body for language detection
+            const fullText = `${issueTitle}\n\n${issueBody}`;
+
+            // Check if the text is too short to reliably detect language
+            if (fullText.trim().length < 20) {
+              console.log('Text too short for reliable language detection');
+              core.setOutput('should_continue', 'false'); // Skip processing for very short text
+              return;
+            }
+
+            core.setOutput('issue_number', issueNumber);
+            core.setOutput('issue_text', fullText);
+            core.setOutput('should_continue', 'true');
+
+      - name: Detect language using AI
+        id: ai_language_detection
+        if: steps.detect_language.outputs.should_continue == 'true'
+        uses: actions/ai-inference@v1.1.0
+        with:
+          model: openai/gpt-4o-mini
+          system-prompt: |
+            You are a language detection system. Your task is to determine if the provided text is written in English or another language.
+
+            Rules:
+            1. Analyze the text and determine the primary language of the USER'S DESCRIPTION only
+            2. IGNORE markdown headers (lines starting with #, ##, ###, etc.) as these are from issue templates, not user input
+            3. IGNORE all code blocks (text between ``` or ` markers) as they may contain system-generated error messages in other languages
+            4. IGNORE error messages, logs, and system output even if not in code blocks - these often appear in the user's system language
+            5. Consider technical terms, code snippets, URLs, and file paths as neutral (they don't indicate non-English)
+            6. Focus ONLY on the actual sentences and descriptions written by the user explaining their issue
+            7. If the user's explanation/description is in English but includes non-English error messages or logs, consider it ENGLISH
+            8. Return ONLY a JSON object with two fields:
+               - "is_english": boolean (true if the user's description is primarily in English, false otherwise)
+               - "detected_language": string (the name of the detected language, e.g., "English", "Spanish", "Chinese", etc.)
+            9. Be lenient - if the user's explanation is in English with non-English system output, it's still English
+            10. Common programming terms, error messages, and technical jargon should not be considered as non-English
+            11. If you cannot reliably determine the language, set detected_language to "undefined"
+
+            Example response:
+            {"is_english": false, "detected_language": "Spanish"}
+
+          prompt: |
+            Please analyze the following issue text and determine if it is written in English:
+
+            ${{ steps.detect_language.outputs.issue_text }}
+
+          max-tokens: 50
+
+      - name: Process non-English issues
+        if: steps.detect_language.outputs.should_continue == 'true'
+        uses: actions/github-script@v7.0.1
+        env:
+          AI_RESPONSE: ${{ steps.ai_language_detection.outputs.response }}
+          ISSUE_NUMBER: ${{ steps.detect_language.outputs.issue_number }}
+        with:
+          script: |
+            const issueNumber = parseInt(process.env.ISSUE_NUMBER);
+            const aiResponse = process.env.AI_RESPONSE;
+
+            console.log('AI language detection response:', aiResponse);
+
+            let languageResult;
+            try {
+              languageResult = JSON.parse(aiResponse.trim());
+
+              // Validate the response structure
+              if (!languageResult || typeof languageResult.is_english !== 'boolean') {
+                throw new Error('Invalid response structure');
+              }
+            } catch (error) {
+              core.error(`Failed to parse AI response: ${error.message}`);
+              console.log('Raw AI response:', aiResponse);
+
+              // Log more details for debugging
+              core.warning('Defaulting to English due to parsing error');
+
+              // Default to English if we can't parse the response
+              return;
+            }
+
+            if (languageResult.is_english) {
+              console.log('Issue is in English, no action needed');
+              return;
+            }
+
+            // If language is undefined or not detected, skip processing
+            if (!languageResult.detected_language || languageResult.detected_language === 'undefined') {
+              console.log('Language could not be determined, skipping processing');
+              return;
+            }
+
+            console.log(`Issue detected as non-English: ${languageResult.detected_language}`);
+
+            // Post comment explaining the language requirement
+            const commentBody = [
+              '<!-- workflow: detect-non-english-issues -->',
+              '### 🌐 Non-English issue detected',
+              '',
+              `This issue appears to be written in **${languageResult.detected_language}** rather than English.`,
+              '',
+              'The Home Assistant project uses English as the primary language for issues to ensure that everyone in our international community can participate and help resolve issues. This allows any of our thousands of contributors to jump in and provide assistance.',
+              '',
+              '**What to do:**',
+              '1. Re-create the issue using the English language',
+              '2. If you need help with translation, consider using:',
+              '   - Translation tools like Google Translate',
+              '   - AI assistants like ChatGPT or Claude',
+              '',
+              'This helps our community provide the best possible support and ensures your issue gets the attention it deserves from our global contributor base.',
+              '',
+              'Thank you for your understanding! 🙏'
+            ].join('\n');
+
+            try {
+              // Add comment
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                body: commentBody
+              });
+
+              console.log('Posted language requirement comment');
+
+              // Add non-english label
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                labels: ['non-english']
+              });
+
+              console.log('Added non-english label');
+
+              // Close the issue
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                state: 'closed',
+                state_reason: 'not_planned'
+              });
+
+              console.log('Closed the issue');
+
+            } catch (error) {
+              core.error('Failed to process non-English issue:', error.message);
+              if (error.status === 403) {
+                core.error('Permission denied or rate limit exceeded');
+              }
+            }

.pre-commit-config.yaml

@@ -1,8 +1,8 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.11.0
+    rev: v0.11.12
     hooks:
-      - id: ruff
+      - id: ruff-check
         args:
           - --fix
       - id: ruff-format
@@ -30,7 +30,7 @@ repos:
           - --branch=master
           - --branch=rc
   - repo: https://github.com/adrienverge/yamllint.git
-    rev: v1.35.1
+    rev: v1.37.1
     hooks:
       - id: yamllint
   - repo: https://github.com/pre-commit/mirrors-prettier

.strict-typing

@@ -65,6 +65,7 @@ homeassistant.components.aladdin_connect.*
 homeassistant.components.alarm_control_panel.*
 homeassistant.components.alert.*
 homeassistant.components.alexa.*
+homeassistant.components.alexa_devices.*
 homeassistant.components.alpha_vantage.*
 homeassistant.components.amazon_polly.*
 homeassistant.components.amberelectric.*
@@ -270,6 +271,7 @@ homeassistant.components.image_processing.*
 homeassistant.components.image_upload.*
 homeassistant.components.imap.*
 homeassistant.components.imgw_pib.*
+homeassistant.components.immich.*
 homeassistant.components.incomfort.*
 homeassistant.components.input_button.*
 homeassistant.components.input_select.*
@@ -385,6 +387,7 @@ homeassistant.components.overseerr.*
 homeassistant.components.p1_monitor.*
 homeassistant.components.pandora.*
 homeassistant.components.panel_custom.*
+homeassistant.components.paperless_ngx.*
 homeassistant.components.peblar.*
 homeassistant.components.peco.*
 homeassistant.components.pegel_online.*

.vscode/tasks.json

@@ -45,7 +45,7 @@
     {
       "label": "Ruff",
       "type": "shell",
-      "command": "pre-commit run ruff --all-files",
+      "command": "pre-commit run ruff-check --all-files",
       "group": {
         "kind": "test",
         "isDefault": true

CODEOWNERS

@@ -57,6 +57,8 @@ build.json @home-assistant/supervisor
 /tests/components/aemet/ @Noltari
 /homeassistant/components/agent_dvr/ @ispysoftware
 /tests/components/agent_dvr/ @ispysoftware
+/homeassistant/components/ai_task/ @home-assistant/core
+/tests/components/ai_task/ @home-assistant/core
 /homeassistant/components/air_quality/ @home-assistant/core
 /tests/components/air_quality/ @home-assistant/core
 /homeassistant/components/airgradient/ @airgradienthq @joostlek
@@ -89,6 +91,8 @@ build.json @home-assistant/supervisor
 /tests/components/alert/ @home-assistant/core @frenck
 /homeassistant/components/alexa/ @home-assistant/cloud @ochlocracy @jbouwh
 /tests/components/alexa/ @home-assistant/cloud @ochlocracy @jbouwh
+/homeassistant/components/alexa_devices/ @chemelli74
+/tests/components/alexa_devices/ @chemelli74
 /homeassistant/components/amazon_polly/ @jschlyter
 /homeassistant/components/amberelectric/ @madpilot
 /tests/components/amberelectric/ @madpilot
@@ -202,8 +206,8 @@ build.json @home-assistant/supervisor
 /tests/components/blebox/ @bbx-a @swistakm
 /homeassistant/components/blink/ @fronzbot @mkmer
 /tests/components/blink/ @fronzbot @mkmer
-/homeassistant/components/blue_current/ @Floris272 @gleeuwen
-/tests/components/blue_current/ @Floris272 @gleeuwen
+/homeassistant/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
+/tests/components/blue_current/ @gleeuwen @NickKoepr @jtodorova23
 /homeassistant/components/bluemaestro/ @bdraco
 /tests/components/bluemaestro/ @bdraco
 /homeassistant/components/blueprint/ @home-assistant/core
@@ -303,6 +307,7 @@ build.json @home-assistant/supervisor
 /homeassistant/components/crownstone/ @Crownstone @RicArch97
 /tests/components/crownstone/ @Crownstone @RicArch97
 /homeassistant/components/cups/ @fabaff
+/tests/components/cups/ @fabaff
 /homeassistant/components/daikin/ @fredrike
 /tests/components/daikin/ @fredrike
 /homeassistant/components/date/ @home-assistant/core
@@ -710,6 +715,8 @@ build.json @home-assistant/supervisor
 /tests/components/imeon_inverter/ @Imeon-Energy
 /homeassistant/components/imgw_pib/ @bieniu
 /tests/components/imgw_pib/ @bieniu
+/homeassistant/components/immich/ @mib1185
+/tests/components/immich/ @mib1185
 /homeassistant/components/improv_ble/ @emontnemery
 /tests/components/improv_ble/ @emontnemery
 /homeassistant/components/incomfort/ @jbouwh
@@ -1138,6 +1145,8 @@ build.json @home-assistant/supervisor
 /tests/components/palazzetti/ @dotvav
 /homeassistant/components/panel_custom/ @home-assistant/frontend
 /tests/components/panel_custom/ @home-assistant/frontend
+/homeassistant/components/paperless_ngx/ @fvgarrel
+/tests/components/paperless_ngx/ @fvgarrel
 /homeassistant/components/peblar/ @frenck
 /tests/components/peblar/ @frenck
 /homeassistant/components/peco/ @IceBotYT
@@ -1176,6 +1185,8 @@ build.json @home-assistant/supervisor
 /tests/components/powerwall/ @bdraco @jrester @daniel-simpson
 /homeassistant/components/private_ble_device/ @Jc2k
 /tests/components/private_ble_device/ @Jc2k
+/homeassistant/components/probe_plus/ @pantherale0
+/tests/components/probe_plus/ @pantherale0
 /homeassistant/components/profiler/ @bdraco
 /tests/components/profiler/ @bdraco
 /homeassistant/components/progettihwsw/ @ardaseremet
@@ -1222,6 +1233,7 @@ build.json @home-assistant/supervisor
 /homeassistant/components/qnap_qsw/ @Noltari
 /tests/components/qnap_qsw/ @Noltari
 /homeassistant/components/quantum_gateway/ @cisasteelersfan
+/tests/components/quantum_gateway/ @cisasteelersfan
 /homeassistant/components/qvr_pro/ @oblogic7
 /homeassistant/components/qwikswitch/ @kellerza
 /tests/components/qwikswitch/ @kellerza
@@ -1264,8 +1276,8 @@ build.json @home-assistant/supervisor
 /tests/components/rehlko/ @bdraco @peterager
 /homeassistant/components/remote/ @home-assistant/core
 /tests/components/remote/ @home-assistant/core
-/homeassistant/components/remote_calendar/ @Thomas55555
-/tests/components/remote_calendar/ @Thomas55555
+/homeassistant/components/remote_calendar/ @Thomas55555 @allenporter
+/tests/components/remote_calendar/ @Thomas55555 @allenporter
 /homeassistant/components/renault/ @epenet
 /tests/components/renault/ @epenet
 /homeassistant/components/renson/ @jimmyd-be
@@ -1410,6 +1422,8 @@ build.json @home-assistant/supervisor
 /tests/components/sma/ @kellerza @rklomp @erwindouna
 /homeassistant/components/smappee/ @bsmappee
 /tests/components/smappee/ @bsmappee
+/homeassistant/components/smarla/ @explicatis @rlint-explicatis
+/tests/components/smarla/ @explicatis @rlint-explicatis
 /homeassistant/components/smart_meter_texas/ @grahamwetzler
 /tests/components/smart_meter_texas/ @grahamwetzler
 /homeassistant/components/smartthings/ @joostlek
@@ -1484,8 +1498,8 @@ build.json @home-assistant/supervisor
 /tests/components/subaru/ @G-Two
 /homeassistant/components/suez_water/ @ooii @jb101010-2
 /tests/components/suez_water/ @ooii @jb101010-2
-/homeassistant/components/sun/ @Swamp-Ig
-/tests/components/sun/ @Swamp-Ig
+/homeassistant/components/sun/ @home-assistant/core
+/tests/components/sun/ @home-assistant/core
 /homeassistant/components/supla/ @mwegrzynek
 /homeassistant/components/surepetcare/ @benleb @danielhiversen
 /tests/components/surepetcare/ @benleb @danielhiversen
@@ -1498,8 +1512,8 @@ build.json @home-assistant/supervisor
 /tests/components/switch_as_x/ @home-assistant/core
 /homeassistant/components/switchbee/ @jafar-atili
 /tests/components/switchbee/ @jafar-atili
-/homeassistant/components/switchbot/ @danielhiversen @RenierM26 @murtas @Eloston @dsypniewski
-/tests/components/switchbot/ @danielhiversen @RenierM26 @murtas @Eloston @dsypniewski
+/homeassistant/components/switchbot/ @danielhiversen @RenierM26 @murtas @Eloston @dsypniewski @zerzhang
+/tests/components/switchbot/ @danielhiversen @RenierM26 @murtas @Eloston @dsypniewski @zerzhang
 /homeassistant/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur
 /tests/components/switchbot_cloud/ @SeraphicRav @laurence-presland @Gigatrappeur
 /homeassistant/components/switcher_kis/ @thecode @YogevBokobza
@@ -1539,8 +1553,8 @@ build.json @home-assistant/supervisor
 /tests/components/tedee/ @patrickhilker @zweckj
 /homeassistant/components/tellduslive/ @fredrike
 /tests/components/tellduslive/ @fredrike
-/homeassistant/components/template/ @Petro31 @PhracturedBlue @home-assistant/core
-/tests/components/template/ @Petro31 @PhracturedBlue @home-assistant/core
+/homeassistant/components/template/ @Petro31 @home-assistant/core
+/tests/components/template/ @Petro31 @home-assistant/core
 /homeassistant/components/tesla_fleet/ @Bre77
 /tests/components/tesla_fleet/ @Bre77
 /homeassistant/components/tesla_wall_connector/ @einarhauks

homeassistant/backports/enum.py

@@ -1,29 +0,0 @@
-"""Enum backports from standard lib.
-
-This file contained the backport of the StrEnum of Python 3.11.
-
-Since we have dropped support for Python 3.10, we can remove this backport.
-This file is kept for now to avoid breaking custom components that might
-import it.
-"""
-
-from __future__ import annotations
-
-from enum import StrEnum as _StrEnum
-from functools import partial
-
-from homeassistant.helpers.deprecation import (
-    DeprecatedAlias,
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
-)
-
-# StrEnum deprecated as of 2024.5 use enum.StrEnum instead.
-_DEPRECATED_StrEnum = DeprecatedAlias(_StrEnum, "enum.StrEnum", "2025.5")
-
-__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())

homeassistant/backports/functools.py

@@ -1,31 +0,0 @@
-"""Functools backports from standard lib.
-
-This file contained the backport of the cached_property implementation of Python 3.12.
-
-Since we have dropped support for Python 3.11, we can remove this backport.
-This file is kept for now to avoid breaking custom components that might
-import it.
-"""
-
-from __future__ import annotations
-
-# pylint: disable-next=hass-deprecated-import
-from functools import cached_property as _cached_property, partial
-
-from homeassistant.helpers.deprecation import (
-    DeprecatedAlias,
-    all_with_deprecated_constants,
-    check_if_deprecated_constant,
-    dir_with_deprecated_constants,
-)
-
-# cached_property deprecated as of 2024.5 use functools.cached_property instead.
-_DEPRECATED_cached_property = DeprecatedAlias(
-    _cached_property, "functools.cached_property", "2025.5"
-)
-
-__getattr__ = partial(check_if_deprecated_constant, module_globals=globals())
-__dir__ = partial(
-    dir_with_deprecated_constants, module_globals_keys=[*globals().keys()]
-)
-__all__ = all_with_deprecated_constants(globals())

homeassistant/bootstrap.py

@@ -171,8 +171,6 @@ FRONTEND_INTEGRATIONS = {
 # Stage 0 is divided into substages. Each substage has a name, a set of integrations and a timeout.
 # The substage containing recorder should have no timeout, as it could cancel a database migration.
 # Recorder freezes "recorder" timeout during a migration, but it does not freeze other timeouts.
-# The substages preceding it should also have no timeout, until we ensure that the recorder
-# is not accidentally promoted as a dependency of any of the integrations in them.
 # If we add timeouts to the frontend substages, we should make sure they don't apply in recovery mode.
 STAGE_0_INTEGRATIONS = (
     # Load logging and http deps as soon as possible
@@ -929,7 +927,11 @@ async def _async_set_up_integrations(
             await _async_setup_multi_components(hass, stage_all_domains, config)
             continue
         try:
-            async with hass.timeout.async_timeout(timeout, cool_down=COOLDOWN_TIME):
+            async with hass.timeout.async_timeout(
+                timeout,
+                cool_down=COOLDOWN_TIME,
+                cancel_message=f"Bootstrap stage {name} timeout",
+            ):
                 await _async_setup_multi_components(hass, stage_all_domains, config)
         except TimeoutError:
             _LOGGER.warning(
@@ -941,7 +943,11 @@ async def _async_set_up_integrations(
     # Wrap up startup
     _LOGGER.debug("Waiting for startup to wrap up")
     try:
-        async with hass.timeout.async_timeout(WRAP_UP_TIMEOUT, cool_down=COOLDOWN_TIME):
+        async with hass.timeout.async_timeout(
+            WRAP_UP_TIMEOUT,
+            cool_down=COOLDOWN_TIME,
+            cancel_message="Bootstrap startup wrap up timeout",
+        ):
             await hass.async_block_till_done()
     except TimeoutError:
         _LOGGER.warning(

homeassistant/brands/amazon.json

@@ -3,6 +3,7 @@
   "name": "Amazon",
   "integrations": [
     "alexa",
+    "alexa_devices",
     "amazon_polly",
     "aws",
     "aws_s3",

homeassistant/brands/shelly.json

@@ -0,0 +1,6 @@
+{
+  "domain": "shelly",
+  "name": "shelly",
+  "integrations": ["shelly"],
+  "iot_standards": ["zwave"]
+}

homeassistant/components/abode/__init__.py

@@ -14,30 +14,24 @@ from jaraco.abode.exceptions import (
 )
 from jaraco.abode.helpers.timeline import Groups as GROUPS
 from requests.exceptions import ConnectTimeout, HTTPError
-import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     ATTR_DATE,
     ATTR_DEVICE_ID,
-    ATTR_ENTITY_ID,
     ATTR_TIME,
     CONF_PASSWORD,
     CONF_USERNAME,
     EVENT_HOMEASSISTANT_STOP,
     Platform,
 )
-from homeassistant.core import CALLBACK_TYPE, Event, HomeAssistant, ServiceCall
+from homeassistant.core import CALLBACK_TYPE, Event, HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers import config_validation as cv
-from homeassistant.helpers.dispatcher import dispatcher_send
 from homeassistant.helpers.typing import ConfigType
 
 from .const import CONF_POLLING, DOMAIN, LOGGER
-
-SERVICE_SETTINGS = "change_setting"
-SERVICE_CAPTURE_IMAGE = "capture_image"
-SERVICE_TRIGGER_AUTOMATION = "trigger_automation"
+from .services import async_setup_services
 
 ATTR_DEVICE_NAME = "device_name"
 ATTR_DEVICE_TYPE = "device_type"
@@ -45,22 +39,12 @@ ATTR_EVENT_CODE = "event_code"
 ATTR_EVENT_NAME = "event_name"
 ATTR_EVENT_TYPE = "event_type"
 ATTR_EVENT_UTC = "event_utc"
-ATTR_SETTING = "setting"
 ATTR_USER_NAME = "user_name"
 ATTR_APP_TYPE = "app_type"
 ATTR_EVENT_BY = "event_by"
-ATTR_VALUE = "value"
 
 CONFIG_SCHEMA = cv.removed(DOMAIN, raise_if_present=False)
 
-CHANGE_SETTING_SCHEMA = vol.Schema(
-    {vol.Required(ATTR_SETTING): cv.string, vol.Required(ATTR_VALUE): cv.string}
-)
-
-CAPTURE_IMAGE_SCHEMA = vol.Schema({ATTR_ENTITY_ID: cv.entity_ids})
-
-AUTOMATION_SCHEMA = vol.Schema({ATTR_ENTITY_ID: cv.entity_ids})
-
 PLATFORMS = [
     Platform.ALARM_CONTROL_PANEL,
     Platform.BINARY_SENSOR,
@@ -85,7 +69,7 @@ class AbodeSystem:
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Abode component."""
-    setup_hass_services(hass)
+    async_setup_services(hass)
     return True
 
 
@@ -138,60 +122,6 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     return unload_ok
 
 
-def setup_hass_services(hass: HomeAssistant) -> None:
-    """Home Assistant services."""
-
-    def change_setting(call: ServiceCall) -> None:
-        """Change an Abode system setting."""
-        setting = call.data[ATTR_SETTING]
-        value = call.data[ATTR_VALUE]
-
-        try:
-            hass.data[DOMAIN].abode.set_setting(setting, value)
-        except AbodeException as ex:
-            LOGGER.warning(ex)
-
-    def capture_image(call: ServiceCall) -> None:
-        """Capture a new image."""
-        entity_ids = call.data[ATTR_ENTITY_ID]
-
-        target_entities = [
-            entity_id
-            for entity_id in hass.data[DOMAIN].entity_ids
-            if entity_id in entity_ids
-        ]
-
-        for entity_id in target_entities:
-            signal = f"abode_camera_capture_{entity_id}"
-            dispatcher_send(hass, signal)
-
-    def trigger_automation(call: ServiceCall) -> None:
-        """Trigger an Abode automation."""
-        entity_ids = call.data[ATTR_ENTITY_ID]
-
-        target_entities = [
-            entity_id
-            for entity_id in hass.data[DOMAIN].entity_ids
-            if entity_id in entity_ids
-        ]
-
-        for entity_id in target_entities:
-            signal = f"abode_trigger_automation_{entity_id}"
-            dispatcher_send(hass, signal)
-
-    hass.services.async_register(
-        DOMAIN, SERVICE_SETTINGS, change_setting, schema=CHANGE_SETTING_SCHEMA
-    )
-
-    hass.services.async_register(
-        DOMAIN, SERVICE_CAPTURE_IMAGE, capture_image, schema=CAPTURE_IMAGE_SCHEMA
-    )
-
-    hass.services.async_register(
-        DOMAIN, SERVICE_TRIGGER_AUTOMATION, trigger_automation, schema=AUTOMATION_SCHEMA
-    )
-
-
 async def setup_hass_events(hass: HomeAssistant) -> None:
     """Home Assistant start and stop callbacks."""
 

homeassistant/components/abode/services.py

@@ -0,0 +1,90 @@
+"""Support for the Abode Security System."""
+
+from __future__ import annotations
+
+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.helpers import config_validation as cv
+from homeassistant.helpers.dispatcher import dispatcher_send
+
+from .const import DOMAIN, LOGGER
+
+SERVICE_SETTINGS = "change_setting"
+SERVICE_CAPTURE_IMAGE = "capture_image"
+SERVICE_TRIGGER_AUTOMATION = "trigger_automation"
+
+ATTR_SETTING = "setting"
+ATTR_VALUE = "value"
+
+
+CHANGE_SETTING_SCHEMA = vol.Schema(
+    {vol.Required(ATTR_SETTING): cv.string, vol.Required(ATTR_VALUE): cv.string}
+)
+
+CAPTURE_IMAGE_SCHEMA = vol.Schema({ATTR_ENTITY_ID: cv.entity_ids})
+
+AUTOMATION_SCHEMA = vol.Schema({ATTR_ENTITY_ID: cv.entity_ids})
+
+
+def _change_setting(call: ServiceCall) -> None:
+    """Change an Abode system setting."""
+    setting = call.data[ATTR_SETTING]
+    value = call.data[ATTR_VALUE]
+
+    try:
+        call.hass.data[DOMAIN].abode.set_setting(setting, value)
+    except AbodeException as ex:
+        LOGGER.warning(ex)
+
+
+def _capture_image(call: ServiceCall) -> None:
+    """Capture a new image."""
+    entity_ids = call.data[ATTR_ENTITY_ID]
+
+    target_entities = [
+        entity_id
+        for entity_id in call.hass.data[DOMAIN].entity_ids
+        if entity_id in entity_ids
+    ]
+
+    for entity_id in target_entities:
+        signal = f"abode_camera_capture_{entity_id}"
+        dispatcher_send(call.hass, signal)
+
+
+def _trigger_automation(call: ServiceCall) -> None:
+    """Trigger an Abode automation."""
+    entity_ids = call.data[ATTR_ENTITY_ID]
+
+    target_entities = [
+        entity_id
+        for entity_id in call.hass.data[DOMAIN].entity_ids
+        if entity_id in entity_ids
+    ]
+
+    for entity_id in target_entities:
+        signal = f"abode_trigger_automation_{entity_id}"
+        dispatcher_send(call.hass, signal)
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Home Assistant services."""
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_SETTINGS, _change_setting, schema=CHANGE_SETTING_SCHEMA
+    )
+
+    hass.services.async_register(
+        DOMAIN, SERVICE_CAPTURE_IMAGE, _capture_image, schema=CAPTURE_IMAGE_SCHEMA
+    )
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_TRIGGER_AUTOMATION,
+        _trigger_automation,
+        schema=AUTOMATION_SCHEMA,
+    )

homeassistant/components/acmeda/config_flow.py

@@ -40,9 +40,10 @@ class AcmedaFlowHandler(ConfigFlow, domain=DOMAIN):
             entry.unique_id for entry in self._async_current_entries()
         }
 
+        hubs: list[aiopulse.Hub] = []
         with suppress(TimeoutError):
             async with timeout(5):
-                hubs: list[aiopulse.Hub] = [
+                hubs = [
                     hub
                     async for hub in aiopulse.Hub.discover()
                     if hub.id not in already_configured

homeassistant/components/adax/__init__.py

@@ -8,7 +8,7 @@ from homeassistant.core import HomeAssistant
 from .const import CONNECTION_TYPE, LOCAL
 from .coordinator import AdaxCloudCoordinator, AdaxConfigEntry, AdaxLocalCoordinator
 
-PLATFORMS = [Platform.CLIMATE]
+PLATFORMS = [Platform.CLIMATE, Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AdaxConfigEntry) -> bool:

homeassistant/components/adax/coordinator.py

@@ -41,7 +41,30 @@ class AdaxCloudCoordinator(DataUpdateCoordinator[dict[str, dict[str, Any]]]):
 
     async def _async_update_data(self) -> dict[str, dict[str, Any]]:
         """Fetch data from the Adax."""
-        rooms = await self.adax_data_handler.get_rooms() or []
+        try:
+            if hasattr(self.adax_data_handler, "fetch_rooms_info"):
+                rooms = await self.adax_data_handler.fetch_rooms_info() or []
+                _LOGGER.debug("fetch_rooms_info returned: %s", rooms)
+            else:
+                _LOGGER.debug("fetch_rooms_info method not available, using get_rooms")
+                rooms = []
+
+            if not rooms:
+                _LOGGER.debug(
+                    "No rooms from fetch_rooms_info, trying get_rooms as fallback"
+                )
+                rooms = await self.adax_data_handler.get_rooms() or []
+                _LOGGER.debug("get_rooms fallback returned: %s", rooms)
+
+            if not rooms:
+                raise UpdateFailed("No rooms available from Adax API")
+
+        except OSError as e:
+            raise UpdateFailed(f"Error communicating with API: {e}") from e
+
+        for room in rooms:
+            room["energyWh"] = int(room.get("energyWh", 0))
+
         return {r["id"]: r for r in rooms}
 
 

homeassistant/components/adax/sensor.py

@@ -0,0 +1,77 @@
+"""Support for Adax energy sensors."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorStateClass,
+)
+from homeassistant.const import UnitOfEnergy
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from . import AdaxConfigEntry
+from .const import CONNECTION_TYPE, DOMAIN, LOCAL
+from .coordinator import AdaxCloudCoordinator
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AdaxConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up the Adax energy sensors with config flow."""
+    if entry.data.get(CONNECTION_TYPE) != LOCAL:
+        cloud_coordinator = cast(AdaxCloudCoordinator, entry.runtime_data)
+
+        # Create individual energy sensors for each device
+        async_add_entities(
+            AdaxEnergySensor(cloud_coordinator, device_id)
+            for device_id in cloud_coordinator.data
+        )
+
+
+class AdaxEnergySensor(CoordinatorEntity[AdaxCloudCoordinator], SensorEntity):
+    """Representation of an Adax energy sensor."""
+
+    _attr_has_entity_name = True
+    _attr_translation_key = "energy"
+    _attr_device_class = SensorDeviceClass.ENERGY
+    _attr_native_unit_of_measurement = UnitOfEnergy.WATT_HOUR
+    _attr_suggested_unit_of_measurement = UnitOfEnergy.KILO_WATT_HOUR
+    _attr_state_class = SensorStateClass.TOTAL_INCREASING
+    _attr_suggested_display_precision = 3
+
+    def __init__(
+        self,
+        coordinator: AdaxCloudCoordinator,
+        device_id: str,
+    ) -> None:
+        """Initialize the energy sensor."""
+        super().__init__(coordinator)
+        self._device_id = device_id
+        room = coordinator.data[device_id]
+
+        self._attr_unique_id = f"{room['homeId']}_{device_id}_energy"
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, device_id)},
+            name=room["name"],
+            manufacturer="Adax",
+        )
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return (
+            super().available and "energyWh" in self.coordinator.data[self._device_id]
+        )
+
+    @property
+    def native_value(self) -> int:
+        """Return the native value of the sensor."""
+        return int(self.coordinator.data[self._device_id]["energyWh"])

homeassistant/components/agent_dvr/camera.py

@@ -15,7 +15,7 @@ from homeassistant.helpers.entity_platform import (
 )
 
 from . import AgentDVRConfigEntry
-from .const import ATTRIBUTION, CAMERA_SCAN_INTERVAL_SECS, DOMAIN as AGENT_DOMAIN
+from .const import ATTRIBUTION, CAMERA_SCAN_INTERVAL_SECS, DOMAIN
 
 SCAN_INTERVAL = timedelta(seconds=CAMERA_SCAN_INTERVAL_SECS)
 
@@ -82,7 +82,7 @@ class AgentCamera(MjpegCamera):
             still_image_url=f"{device.client._server_url}{device.still_image_url}&size={device.mjpegStreamWidth}x{device.mjpegStreamHeight}",  # noqa: SLF001
         )
         self._attr_device_info = DeviceInfo(
-            identifiers={(AGENT_DOMAIN, self.unique_id)},
+            identifiers={(DOMAIN, self.unique_id)},
             manufacturer="Agent",
             model="Camera",
             name=f"{device.client.name} {device.name}",

homeassistant/components/ai_task/__init__.py

@@ -0,0 +1,99 @@
+"""Integration to offer AI tasks to Home Assistant."""
+
+import logging
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import config_validation as cv, storage
+from homeassistant.helpers.entity_component import EntityComponent
+from homeassistant.helpers.typing import UNDEFINED, ConfigType, UndefinedType
+
+from .const import DATA_COMPONENT, DATA_PREFERENCES, DOMAIN
+from .entity import AITaskEntity
+from .http import async_setup as async_setup_conversation_http
+from .task import GenTextTask, GenTextTaskResult, async_generate_text
+
+__all__ = [
+    "DOMAIN",
+    "AITaskEntity",
+    "GenTextTask",
+    "GenTextTaskResult",
+    "async_generate_text",
+    "async_setup",
+    "async_setup_entry",
+    "async_unload_entry",
+]
+
+_LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Register the process service."""
+    entity_component = EntityComponent[AITaskEntity](_LOGGER, DOMAIN, hass)
+    hass.data[DATA_COMPONENT] = entity_component
+    hass.data[DATA_PREFERENCES] = AITaskPreferences(hass)
+    await hass.data[DATA_PREFERENCES].async_load()
+    async_setup_conversation_http(hass)
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up a config entry."""
+    return await hass.data[DATA_COMPONENT].async_setup_entry(entry)
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
+
+
+class AITaskPreferences:
+    """AI Task preferences."""
+
+    gen_text_entity_id: str | None = None
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        """Initialize the preferences."""
+        self._store: storage.Store[dict[str, str | None]] = storage.Store(
+            hass, 1, DOMAIN
+        )
+
+    async def async_load(self) -> None:
+        """Load the data from the store."""
+        data = await self._store.async_load()
+        if data is None:
+            return
+        self.gen_text_entity_id = data.get("gen_text_entity_id")
+
+    @callback
+    def async_set_preferences(
+        self,
+        *,
+        gen_text_entity_id: str | None | UndefinedType = UNDEFINED,
+    ) -> None:
+        """Set the preferences."""
+        changed = False
+        for key, value in (("gen_text_entity_id", gen_text_entity_id),):
+            if value is not UNDEFINED:
+                if getattr(self, key) != value:
+                    setattr(self, key, value)
+                    changed = True
+
+        if not changed:
+            return
+
+        self._store.async_delay_save(
+            lambda: {
+                "gen_text_entity_id": self.gen_text_entity_id,
+            },
+            10,
+        )
+
+    @callback
+    def as_dict(self) -> dict[str, str | None]:
+        """Get the current preferences."""
+        return {
+            "gen_text_entity_id": self.gen_text_entity_id,
+        }

homeassistant/components/ai_task/const.py

@@ -0,0 +1,21 @@
+"""Constants for the AI Task integration."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from homeassistant.util.hass_dict import HassKey
+
+if TYPE_CHECKING:
+    from homeassistant.helpers.entity_component import EntityComponent
+
+    from . import AITaskPreferences
+    from .entity import AITaskEntity
+
+DOMAIN = "ai_task"
+DATA_COMPONENT: HassKey[EntityComponent[AITaskEntity]] = HassKey(DOMAIN)
+DATA_PREFERENCES: HassKey[AITaskPreferences] = HassKey(f"{DOMAIN}_preferences")
+
+DEFAULT_SYSTEM_PROMPT = (
+    "You are a Home Assistant expert and help users with their tasks."
+)

homeassistant/components/ai_task/entity.py

@@ -0,0 +1,95 @@
+"""Entity for the AI Task integration."""
+
+from collections.abc import AsyncGenerator
+import contextlib
+from typing import final
+
+from homeassistant.components.conversation import (
+    ChatLog,
+    UserContent,
+    async_get_chat_log,
+)
+from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
+from homeassistant.helpers import llm
+from homeassistant.helpers.chat_session import async_get_chat_session
+from homeassistant.helpers.restore_state import RestoreEntity
+from homeassistant.util import dt as dt_util
+
+from .const import DEFAULT_SYSTEM_PROMPT, DOMAIN
+from .task import GenTextTask, GenTextTaskResult
+
+
+class AITaskEntity(RestoreEntity):
+    """Entity that supports conversations."""
+
+    _attr_should_poll = False
+    __last_activity: str | None = None
+
+    @property
+    @final
+    def state(self) -> str | None:
+        """Return the state of the entity."""
+        if self.__last_activity is None:
+            return None
+        return self.__last_activity
+
+    async def async_internal_added_to_hass(self) -> None:
+        """Call when the entity is added to hass."""
+        await super().async_internal_added_to_hass()
+        state = await self.async_get_last_state()
+        if (
+            state is not None
+            and state.state is not None
+            and state.state not in (STATE_UNAVAILABLE, STATE_UNKNOWN)
+        ):
+            self.__last_activity = state.state
+
+    @final
+    @contextlib.asynccontextmanager
+    async def _async_get_ai_task_chat_log(
+        self,
+        task: GenTextTask,
+    ) -> AsyncGenerator[ChatLog]:
+        """Context manager used to manage the ChatLog used during an AI Task."""
+        # pylint: disable-next=contextmanager-generator-missing-cleanup
+        with (
+            async_get_chat_session(self.hass) as session,
+            async_get_chat_log(
+                self.hass,
+                session,
+                None,
+            ) as chat_log,
+        ):
+            await chat_log.async_provide_llm_data(
+                llm.LLMContext(
+                    platform=self.platform.domain,
+                    context=None,
+                    language=None,
+                    assistant=DOMAIN,
+                    device_id=None,
+                ),
+                user_llm_prompt=DEFAULT_SYSTEM_PROMPT,
+            )
+
+            chat_log.async_add_user_content(UserContent(task.instructions))
+
+            yield chat_log
+
+    @final
+    async def internal_async_generate_text(
+        self,
+        task: GenTextTask,
+    ) -> GenTextTaskResult:
+        """Run a gen text task."""
+        self.__last_activity = dt_util.utcnow().isoformat()
+        self.async_write_ha_state()
+        async with self._async_get_ai_task_chat_log(task) as chat_log:
+            return await self._async_generate_text(task, chat_log)
+
+    async def _async_generate_text(
+        self,
+        task: GenTextTask,
+        chat_log: ChatLog,
+    ) -> GenTextTaskResult:
+        """Handle a gen text task."""
+        raise NotImplementedError

homeassistant/components/ai_task/http.py

@@ -0,0 +1,82 @@
+"""HTTP endpoint for AI Task integration."""
+
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components import websocket_api
+from homeassistant.core import HomeAssistant, callback
+
+from .const import DATA_PREFERENCES
+from .task import async_generate_text
+
+
+@callback
+def async_setup(hass: HomeAssistant) -> None:
+    """Set up the HTTP API for the conversation integration."""
+    websocket_api.async_register_command(hass, websocket_generate_text)
+    websocket_api.async_register_command(hass, websocket_get_preferences)
+    websocket_api.async_register_command(hass, websocket_set_preferences)
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "ai_task/generate_text",
+        vol.Required("task_name"): str,
+        vol.Optional("entity_id"): str,
+        vol.Required("instructions"): str,
+    }
+)
+@websocket_api.require_admin
+@websocket_api.async_response
+async def websocket_generate_text(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Run a generate text task."""
+    msg.pop("type")
+    msg_id = msg.pop("id")
+    try:
+        result = await async_generate_text(hass=hass, **msg)
+    except ValueError as err:
+        connection.send_error(msg_id, websocket_api.const.ERR_UNKNOWN_ERROR, str(err))
+        return
+    connection.send_result(msg_id, result.as_dict())
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "ai_task/preferences/get",
+    }
+)
+@callback
+def websocket_get_preferences(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Get AI task preferences."""
+    preferences = hass.data[DATA_PREFERENCES]
+    connection.send_result(msg["id"], preferences.as_dict())
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "ai_task/preferences/set",
+        vol.Optional("gen_text_entity_id"): vol.Any(str, None),
+    }
+)
+@websocket_api.require_admin
+@callback
+def websocket_set_preferences(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Set AI task preferences."""
+    preferences = hass.data[DATA_PREFERENCES]
+    msg.pop("type")
+    msg_id = msg.pop("id")
+    preferences.async_set_preferences(**msg)
+    connection.send_result(msg_id, preferences.as_dict())

homeassistant/components/ai_task/manifest.json

@@ -0,0 +1,9 @@
+{
+  "domain": "ai_task",
+  "name": "AI Task",
+  "codeowners": ["@home-assistant/core"],
+  "dependencies": ["conversation"],
+  "documentation": "https://www.home-assistant.io/integrations/ai_task",
+  "integration_type": "system",
+  "quality_scale": "internal"
+}

homeassistant/components/ai_task/task.py

@@ -0,0 +1,68 @@
+"""AI tasks to be handled by agents."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from homeassistant.core import HomeAssistant
+
+from .const import DATA_COMPONENT, DATA_PREFERENCES
+
+
+async def async_generate_text(
+    hass: HomeAssistant,
+    *,
+    task_name: str,
+    entity_id: str | None = None,
+    instructions: str,
+) -> GenTextTaskResult:
+    """Run a task in the AI Task integration."""
+    if entity_id is None:
+        entity_id = hass.data[DATA_PREFERENCES].gen_text_entity_id
+
+    if entity_id is None:
+        raise ValueError("No entity_id provided and no preferred entity set")
+
+    entity = hass.data[DATA_COMPONENT].get_entity(entity_id)
+    if entity is None:
+        raise ValueError(f"AI Task entity {entity_id} not found")
+
+    return await entity.internal_async_generate_text(
+        GenTextTask(
+            name=task_name,
+            instructions=instructions,
+        )
+    )
+
+
+@dataclass(slots=True)
+class GenTextTask:
+    """Gen text task to be processed."""
+
+    name: str
+    """Name of the task."""
+
+    instructions: str
+    """Instructions on what needs to be done."""
+
+    def __str__(self) -> str:
+        """Return task as a string."""
+        return f"<GenTextTask {self.name}: {id(self)}>"
+
+
+@dataclass(slots=True)
+class GenTextTaskResult:
+    """Result of gen text task."""
+
+    conversation_id: str
+    """Unique identifier for the conversation."""
+
+    result: str
+    """Result of the task."""
+
+    def as_dict(self) -> dict[str, str]:
+        """Return result as a dict."""
+        return {
+            "conversation_id": self.conversation_id,
+            "result": self.result,
+        }

homeassistant/components/airgradient/coordinator.py

@@ -51,9 +51,16 @@ class AirGradientCoordinator(DataUpdateCoordinator[AirGradientData]):
 
     async def _async_setup(self) -> None:
         """Set up the coordinator."""
-        self._current_version = (
-            await self.client.get_current_measures()
-        ).firmware_version
+        try:
+            self._current_version = (
+                await self.client.get_current_measures()
+            ).firmware_version
+        except AirGradientError as error:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="update_error",
+                translation_placeholders={"error": str(error)},
+            ) from error
 
     async def _async_update_data(self) -> AirGradientData:
         try:

homeassistant/components/airgradient/entity.py

@@ -6,6 +6,7 @@ from typing import Any, Concatenate
 from airgradient import AirGradientConnectionError, AirGradientError, get_model_name
 
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
@@ -29,6 +30,7 @@ class AirGradientEntity(CoordinatorEntity[AirGradientCoordinator]):
             model_id=measures.model,
             serial_number=coordinator.serial_number,
             sw_version=measures.firmware_version,
+            connections={(dr.CONNECTION_NETWORK_MAC, coordinator.serial_number)},
         )
 
 

homeassistant/components/airq/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_polling",
   "loggers": ["aioairq"],
-  "requirements": ["aioairq==0.4.4"]
+  "requirements": ["aioairq==0.4.6"]
 }

homeassistant/components/airthings/__init__.py

@@ -5,23 +5,22 @@ from __future__ import annotations
 from datetime import timedelta
 import logging
 
-from airthings import Airthings, AirthingsDevice, AirthingsError
+from airthings import Airthings
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ID, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
-from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
-from .const import CONF_SECRET, DOMAIN
+from .const import CONF_SECRET
+from .coordinator import AirthingsDataUpdateCoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 SCAN_INTERVAL = timedelta(minutes=6)
 
-type AirthingsDataCoordinatorType = DataUpdateCoordinator[dict[str, AirthingsDevice]]
-type AirthingsConfigEntry = ConfigEntry[AirthingsDataCoordinatorType]
+type AirthingsConfigEntry = ConfigEntry[AirthingsDataUpdateCoordinator]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: AirthingsConfigEntry) -> bool:
@@ -32,21 +31,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: AirthingsConfigEntry) ->
         async_get_clientsession(hass),
     )
 
-    async def _update_method() -> dict[str, AirthingsDevice]:
-        """Get the latest data from Airthings."""
-        try:
-            return await airthings.update_devices()  # type: ignore[no-any-return]
-        except AirthingsError as err:
-            raise UpdateFailed(f"Unable to fetch data: {err}") from err
+    coordinator = AirthingsDataUpdateCoordinator(hass, airthings)
 
-    coordinator = DataUpdateCoordinator(
-        hass,
-        _LOGGER,
-        config_entry=entry,
-        name=DOMAIN,
-        update_method=_update_method,
-        update_interval=SCAN_INTERVAL,
-    )
     await coordinator.async_config_entry_first_refresh()
 
     entry.runtime_data = coordinator

homeassistant/components/airthings/coordinator.py

@@ -0,0 +1,36 @@
+"""The Airthings integration."""
+
+from datetime import timedelta
+import logging
+
+from airthings import Airthings, AirthingsDevice, AirthingsError
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+SCAN_INTERVAL = timedelta(minutes=6)
+
+
+class AirthingsDataUpdateCoordinator(DataUpdateCoordinator[dict[str, AirthingsDevice]]):
+    """Coordinator for Airthings data updates."""
+
+    def __init__(self, hass: HomeAssistant, airthings: Airthings) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=DOMAIN,
+            update_method=self._update_method,
+            update_interval=SCAN_INTERVAL,
+        )
+        self.airthings = airthings
+
+    async def _update_method(self) -> dict[str, AirthingsDevice]:
+        """Get the latest data from Airthings."""
+        try:
+            return await self.airthings.update_devices()  # type: ignore[no-any-return]
+        except AirthingsError as err:
+            raise UpdateFailed(f"Unable to fetch data: {err}") from err

homeassistant/components/airthings/sensor.py

@@ -19,6 +19,7 @@ from homeassistant.const import (
     SIGNAL_STRENGTH_DECIBELS,
     EntityCategory,
     UnitOfPressure,
+    UnitOfSoundPressure,
     UnitOfTemperature,
 )
 from homeassistant.core import HomeAssistant
@@ -27,32 +28,44 @@ from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.helpers.typing import StateType
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
-from . import AirthingsConfigEntry, AirthingsDataCoordinatorType
+from . import AirthingsConfigEntry
 from .const import DOMAIN
+from .coordinator import AirthingsDataUpdateCoordinator
 
 SENSORS: dict[str, SensorEntityDescription] = {
     "radonShortTermAvg": SensorEntityDescription(
         key="radonShortTermAvg",
         native_unit_of_measurement="Bq/m³",
         translation_key="radon",
+        suggested_display_precision=0,
     ),
     "temp": SensorEntityDescription(
         key="temp",
         device_class=SensorDeviceClass.TEMPERATURE,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=1,
     ),
     "humidity": SensorEntityDescription(
         key="humidity",
         device_class=SensorDeviceClass.HUMIDITY,
         native_unit_of_measurement=PERCENTAGE,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "pressure": SensorEntityDescription(
         key="pressure",
         device_class=SensorDeviceClass.ATMOSPHERIC_PRESSURE,
         native_unit_of_measurement=UnitOfPressure.MBAR,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=1,
+    ),
+    "sla": SensorEntityDescription(
+        key="sla",
+        device_class=SensorDeviceClass.SOUND_PRESSURE,
+        native_unit_of_measurement=UnitOfSoundPressure.WEIGHTED_DECIBEL_A,
+        state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "battery": SensorEntityDescription(
         key="battery",
@@ -60,40 +73,47 @@ SENSORS: dict[str, SensorEntityDescription] = {
         native_unit_of_measurement=PERCENTAGE,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "co2": SensorEntityDescription(
         key="co2",
         device_class=SensorDeviceClass.CO2,
         native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "voc": SensorEntityDescription(
         key="voc",
         device_class=SensorDeviceClass.VOLATILE_ORGANIC_COMPOUNDS_PARTS,
         native_unit_of_measurement=CONCENTRATION_PARTS_PER_BILLION,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "light": SensorEntityDescription(
         key="light",
         native_unit_of_measurement=PERCENTAGE,
         translation_key="light",
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "lux": SensorEntityDescription(
         key="lux",
         device_class=SensorDeviceClass.ILLUMINANCE,
         native_unit_of_measurement=LIGHT_LUX,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "virusRisk": SensorEntityDescription(
         key="virusRisk",
         translation_key="virus_risk",
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "mold": SensorEntityDescription(
         key="mold",
         translation_key="mold",
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "rssi": SensorEntityDescription(
         key="rssi",
@@ -102,18 +122,21 @@ SENSORS: dict[str, SensorEntityDescription] = {
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.DIAGNOSTIC,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "pm1": SensorEntityDescription(
         key="pm1",
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         device_class=SensorDeviceClass.PM1,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
     "pm25": SensorEntityDescription(
         key="pm25",
         native_unit_of_measurement=CONCENTRATION_MICROGRAMS_PER_CUBIC_METER,
         device_class=SensorDeviceClass.PM25,
         state_class=SensorStateClass.MEASUREMENT,
+        suggested_display_precision=0,
     ),
 }
 
@@ -140,7 +163,7 @@ async def async_setup_entry(
 
 
 class AirthingsHeaterEnergySensor(
-    CoordinatorEntity[AirthingsDataCoordinatorType], SensorEntity
+    CoordinatorEntity[AirthingsDataUpdateCoordinator], SensorEntity
 ):
     """Representation of a Airthings Sensor device."""
 
@@ -149,7 +172,7 @@ class AirthingsHeaterEnergySensor(
 
     def __init__(
         self,
-        coordinator: AirthingsDataCoordinatorType,
+        coordinator: AirthingsDataUpdateCoordinator,
         airthings_device: AirthingsDevice,
         entity_description: SensorEntityDescription,
     ) -> None:

homeassistant/components/airtouch4/climate.py

@@ -142,7 +142,7 @@ class AirtouchAC(CoordinatorEntity, ClimateEntity):
         return AT_TO_HA_STATE[self._airtouch.acs[self._ac_number].AcMode]
 
     @property
-    def hvac_modes(self):
+    def hvac_modes(self) -> list[HVACMode]:
         """Return the list of available operation modes."""
         airtouch_modes = self._airtouch.GetSupportedCoolingModesForAc(self._ac_number)
         modes = [AT_TO_HA_STATE[mode] for mode in airtouch_modes]
@@ -226,12 +226,12 @@ class AirtouchGroup(CoordinatorEntity, ClimateEntity):
         return super()._handle_coordinator_update()
 
     @property
-    def min_temp(self):
+    def min_temp(self) -> float:
         """Return Minimum Temperature for AC of this group."""
         return self._airtouch.acs[self._unit.BelongsToAc].MinSetpoint
 
     @property
-    def max_temp(self):
+    def max_temp(self) -> float:
         """Return Max Temperature for AC of this group."""
         return self._airtouch.acs[self._unit.BelongsToAc].MaxSetpoint
 

homeassistant/components/airtouch5/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/airtouch5",
   "iot_class": "local_push",
   "loggers": ["airtouch5py"],
-  "requirements": ["airtouch5py==0.2.11"]
+  "requirements": ["airtouch5py==0.3.0"]
 }

homeassistant/components/alexa_devices/__init__.py

@@ -0,0 +1,32 @@
+"""Alexa Devices integration."""
+
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant
+
+from .coordinator import AmazonConfigEntry, AmazonDevicesCoordinator
+
+PLATFORMS = [
+    Platform.BINARY_SENSOR,
+    Platform.NOTIFY,
+    Platform.SWITCH,
+]
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bool:
+    """Set up Alexa Devices platform."""
+
+    coordinator = AmazonDevicesCoordinator(hass, entry)
+
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: AmazonConfigEntry) -> bool:
+    """Unload a config entry."""
+    await entry.runtime_data.api.close()
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/alexa_devices/binary_sensor.py

@@ -0,0 +1,74 @@
+"""Support for binary sensors."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Final
+
+from aioamazondevices.api import AmazonDevice
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import AmazonConfigEntry
+from .entity import AmazonEntity
+
+# Coordinator is used to centralize the data updates
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AmazonBinarySensorEntityDescription(BinarySensorEntityDescription):
+    """Alexa Devices binary sensor entity description."""
+
+    is_on_fn: Callable[[AmazonDevice], bool]
+
+
+BINARY_SENSORS: Final = (
+    AmazonBinarySensorEntityDescription(
+        key="online",
+        device_class=BinarySensorDeviceClass.CONNECTIVITY,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        is_on_fn=lambda _device: _device.online,
+    ),
+    AmazonBinarySensorEntityDescription(
+        key="bluetooth",
+        entity_category=EntityCategory.DIAGNOSTIC,
+        translation_key="bluetooth",
+        is_on_fn=lambda _device: _device.bluetooth_state,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AmazonConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Alexa Devices binary sensors based on a config entry."""
+
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        AmazonBinarySensorEntity(coordinator, serial_num, sensor_desc)
+        for sensor_desc in BINARY_SENSORS
+        for serial_num in coordinator.data
+    )
+
+
+class AmazonBinarySensorEntity(AmazonEntity, BinarySensorEntity):
+    """Binary sensor device."""
+
+    entity_description: AmazonBinarySensorEntityDescription
+
+    @property
+    def is_on(self) -> bool:
+        """Return True if the binary sensor is on."""
+        return self.entity_description.is_on_fn(self.device)

homeassistant/components/alexa_devices/config_flow.py

@@ -0,0 +1,63 @@
+"""Config flow for Alexa Devices integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from aioamazondevices.api import AmazonEchoApi
+from aioamazondevices.exceptions import CannotAuthenticate, CannotConnect
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_CODE, CONF_COUNTRY, CONF_PASSWORD, CONF_USERNAME
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.selector import CountrySelector
+
+from .const import CONF_LOGIN_DATA, DOMAIN
+
+
+class AmazonDevicesConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Alexa Devices."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors = {}
+        if user_input:
+            client = AmazonEchoApi(
+                user_input[CONF_COUNTRY],
+                user_input[CONF_USERNAME],
+                user_input[CONF_PASSWORD],
+            )
+            try:
+                data = await client.login_mode_interactive(user_input[CONF_CODE])
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except CannotAuthenticate:
+                errors["base"] = "invalid_auth"
+            else:
+                await self.async_set_unique_id(data["customer_info"]["user_id"])
+                self._abort_if_unique_id_configured()
+                user_input.pop(CONF_CODE)
+                return self.async_create_entry(
+                    title=user_input[CONF_USERNAME],
+                    data=user_input | {CONF_LOGIN_DATA: data},
+                )
+            finally:
+                await client.close()
+
+        return self.async_show_form(
+            step_id="user",
+            errors=errors,
+            data_schema=vol.Schema(
+                {
+                    vol.Required(
+                        CONF_COUNTRY, default=self.hass.config.country
+                    ): CountrySelector(),
+                    vol.Required(CONF_USERNAME): cv.string,
+                    vol.Required(CONF_PASSWORD): cv.string,
+                    vol.Required(CONF_CODE): cv.string,
+                }
+            ),
+        )

homeassistant/components/alexa_devices/const.py

@@ -0,0 +1,8 @@
+"""Alexa Devices constants."""
+
+import logging
+
+_LOGGER = logging.getLogger(__package__)
+
+DOMAIN = "alexa_devices"
+CONF_LOGIN_DATA = "login_data"

homeassistant/components/alexa_devices/coordinator.py

@@ -0,0 +1,58 @@
+"""Support for Alexa Devices."""
+
+from datetime import timedelta
+
+from aioamazondevices.api import AmazonDevice, AmazonEchoApi
+from aioamazondevices.exceptions import (
+    CannotAuthenticate,
+    CannotConnect,
+    CannotRetrieveData,
+)
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_COUNTRY, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryError
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
+
+from .const import _LOGGER, CONF_LOGIN_DATA
+
+SCAN_INTERVAL = 30
+
+type AmazonConfigEntry = ConfigEntry[AmazonDevicesCoordinator]
+
+
+class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
+    """Base coordinator for Alexa Devices."""
+
+    config_entry: AmazonConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        entry: AmazonConfigEntry,
+    ) -> None:
+        """Initialize the scanner."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=entry.title,
+            config_entry=entry,
+            update_interval=timedelta(seconds=SCAN_INTERVAL),
+        )
+        self.api = AmazonEchoApi(
+            entry.data[CONF_COUNTRY],
+            entry.data[CONF_USERNAME],
+            entry.data[CONF_PASSWORD],
+            entry.data[CONF_LOGIN_DATA],
+        )
+
+    async def _async_update_data(self) -> dict[str, AmazonDevice]:
+        """Update device data."""
+        try:
+            await self.api.login_mode_stored_data()
+            return await self.api.get_devices_data()
+        except (CannotConnect, CannotRetrieveData) as err:
+            raise UpdateFailed(f"Error occurred while updating {self.name}") from err
+        except CannotAuthenticate as err:
+            raise ConfigEntryError("Could not authenticate") from err

homeassistant/components/alexa_devices/diagnostics.py

@@ -0,0 +1,66 @@
+"""Diagnostics support for Alexa Devices integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from aioamazondevices.api import AmazonDevice
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_NAME, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.device_registry import DeviceEntry
+
+from .coordinator import AmazonConfigEntry
+
+TO_REDACT = {CONF_PASSWORD, CONF_USERNAME, CONF_NAME, "title"}
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: AmazonConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+
+    coordinator = entry.runtime_data
+
+    devices: list[dict[str, dict[str, Any]]] = [
+        build_device_data(device) for device in coordinator.data.values()
+    ]
+
+    return {
+        "entry": async_redact_data(entry.as_dict(), TO_REDACT),
+        "device_info": {
+            "last_update success": coordinator.last_update_success,
+            "last_exception": repr(coordinator.last_exception),
+            "devices": devices,
+        },
+    }
+
+
+async def async_get_device_diagnostics(
+    hass: HomeAssistant, entry: AmazonConfigEntry, device_entry: DeviceEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a device."""
+
+    coordinator = entry.runtime_data
+
+    assert device_entry.serial_number
+
+    return build_device_data(coordinator.data[device_entry.serial_number])
+
+
+def build_device_data(device: AmazonDevice) -> dict[str, Any]:
+    """Build device data for diagnostics."""
+    return {
+        "account name": device.account_name,
+        "capabilities": device.capabilities,
+        "device family": device.device_family,
+        "device type": device.device_type,
+        "device cluster members": device.device_cluster_members,
+        "online": device.online,
+        "serial number": device.serial_number,
+        "software version": device.software_version,
+        "do not disturb": device.do_not_disturb,
+        "response style": device.response_style,
+        "bluetooth state": device.bluetooth_state,
+    }

homeassistant/components/alexa_devices/entity.py

@@ -0,0 +1,57 @@
+"""Defines a base Alexa Devices entity."""
+
+from aioamazondevices.api import AmazonDevice
+from aioamazondevices.const import SPEAKER_GROUP_MODEL
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import AmazonDevicesCoordinator
+
+
+class AmazonEntity(CoordinatorEntity[AmazonDevicesCoordinator]):
+    """Defines a base Alexa Devices entity."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: AmazonDevicesCoordinator,
+        serial_num: str,
+        description: EntityDescription,
+    ) -> None:
+        """Initialize the entity."""
+        super().__init__(coordinator)
+        self._serial_num = serial_num
+        model_details = coordinator.api.get_model_details(self.device) or {}
+        model = model_details.get("model")
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, serial_num)},
+            name=self.device.account_name,
+            model=model,
+            model_id=self.device.device_type,
+            manufacturer=model_details.get("manufacturer", "Amazon"),
+            hw_version=model_details.get("hw_version"),
+            sw_version=(
+                self.device.software_version if model != SPEAKER_GROUP_MODEL else None
+            ),
+            serial_number=serial_num if model != SPEAKER_GROUP_MODEL else None,
+        )
+        self.entity_description = description
+        self._attr_unique_id = f"{serial_num}-{description.key}"
+
+    @property
+    def device(self) -> AmazonDevice:
+        """Return the device."""
+        return self.coordinator.data[self._serial_num]
+
+    @property
+    def available(self) -> bool:
+        """Return True if entity is available."""
+        return (
+            super().available
+            and self._serial_num in self.coordinator.data
+            and self.device.online
+        )

homeassistant/components/alexa_devices/icons.json

@@ -0,0 +1,12 @@
+{
+  "entity": {
+    "binary_sensor": {
+      "bluetooth": {
+        "default": "mdi:bluetooth",
+        "state": {
+          "off": "mdi:bluetooth-off"
+        }
+      }
+    }
+  }
+}

homeassistant/components/alexa_devices/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "alexa_devices",
+  "name": "Alexa Devices",
+  "codeowners": ["@chemelli74"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/alexa_devices",
+  "integration_type": "hub",
+  "iot_class": "cloud_polling",
+  "loggers": ["aioamazondevices"],
+  "quality_scale": "bronze",
+  "requirements": ["aioamazondevices==3.1.4"]
+}

homeassistant/components/alexa_devices/notify.py

@@ -0,0 +1,78 @@
+"""Support for notification entity."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Any, Final
+
+from aioamazondevices.api import AmazonDevice, AmazonEchoApi
+from aioamazondevices.const import SPEAKER_GROUP_FAMILY
+
+from homeassistant.components.notify import NotifyEntity, NotifyEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import AmazonConfigEntry
+from .entity import AmazonEntity
+
+PARALLEL_UPDATES = 1
+
+
+@dataclass(frozen=True, kw_only=True)
+class AmazonNotifyEntityDescription(NotifyEntityDescription):
+    """Alexa Devices notify entity description."""
+
+    is_supported: Callable[[AmazonDevice], bool] = lambda _device: True
+    method: Callable[[AmazonEchoApi, AmazonDevice, str], Awaitable[None]]
+    subkey: str
+
+
+NOTIFY: Final = (
+    AmazonNotifyEntityDescription(
+        key="speak",
+        translation_key="speak",
+        subkey="AUDIO_PLAYER",
+        is_supported=lambda _device: _device.device_family != SPEAKER_GROUP_FAMILY,
+        method=lambda api, device, message: api.call_alexa_speak(device, message),
+    ),
+    AmazonNotifyEntityDescription(
+        key="announce",
+        translation_key="announce",
+        subkey="AUDIO_PLAYER",
+        method=lambda api, device, message: api.call_alexa_announcement(
+            device, message
+        ),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AmazonConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Alexa Devices notification entity based on a config entry."""
+
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        AmazonNotifyEntity(coordinator, serial_num, sensor_desc)
+        for sensor_desc in NOTIFY
+        for serial_num in coordinator.data
+        if sensor_desc.subkey in coordinator.data[serial_num].capabilities
+        and sensor_desc.is_supported(coordinator.data[serial_num])
+    )
+
+
+class AmazonNotifyEntity(AmazonEntity, NotifyEntity):
+    """Binary sensor notify platform."""
+
+    entity_description: AmazonNotifyEntityDescription
+
+    async def async_send_message(
+        self, message: str, title: str | None = None, **kwargs: Any
+    ) -> None:
+        """Send a message."""
+
+        await self.entity_description.method(self.coordinator.api, self.device, message)

homeassistant/components/alexa_devices/quality_scale.yaml

@@ -0,0 +1,76 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: no actions
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: no actions
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: entities do not explicitly subscribe to events
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: todo
+  config-entry-unloading: done
+  docs-configuration-parameters: todo
+  docs-installation-parameters: todo
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: done
+  parallel-updates: done
+  reauthentication-flow: todo
+  test-coverage:
+    status: todo
+    comment: all tests missing
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info:
+    status: exempt
+    comment: Network information not relevant
+  discovery:
+    status: exempt
+    comment: There are a ton of mac address ranges in use, but also by kindles which are not supported by this integration
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: done
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: done
+  reconfiguration-flow: todo
+  repair-issues:
+    status: exempt
+    comment: no known use cases for repair issues or flows, yet
+  stale-devices:
+    status: todo
+    comment: automate the cleanup process
+
+  # Platinum
+  async-dependency: done
+  inject-websession: todo
+  strict-typing: done

homeassistant/components/alexa_devices/strings.json

@@ -0,0 +1,60 @@
+{
+  "common": {
+    "data_country": "Country code",
+    "data_code": "One-time password (OTP code)",
+    "data_description_country": "The country of your Amazon account.",
+    "data_description_username": "The email address of your Amazon account.",
+    "data_description_password": "The password of your Amazon account.",
+    "data_description_code": "The one-time password to log in to your account. Currently, only tokens from OTP applications are supported."
+  },
+  "config": {
+    "flow_title": "{username}",
+    "step": {
+      "user": {
+        "data": {
+          "country": "[%key:component::alexa_devices::common::data_country%]",
+          "username": "[%key:common::config_flow::data::username%]",
+          "password": "[%key:common::config_flow::data::password%]",
+          "code": "[%key:component::alexa_devices::common::data_description_code%]"
+        },
+        "data_description": {
+          "country": "[%key:component::alexa_devices::common::data_description_country%]",
+          "username": "[%key:component::alexa_devices::common::data_description_username%]",
+          "password": "[%key:component::alexa_devices::common::data_description_password%]",
+          "code": "[%key:component::alexa_devices::common::data_description_code%]"
+        }
+      }
+    },
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_service%]",
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    }
+  },
+  "entity": {
+    "binary_sensor": {
+      "bluetooth": {
+        "name": "Bluetooth"
+      }
+    },
+    "notify": {
+      "speak": {
+        "name": "Speak"
+      },
+      "announce": {
+        "name": "Announce"
+      }
+    },
+    "switch": {
+      "do_not_disturb": {
+        "name": "Do not disturb"
+      }
+    }
+  }
+}

homeassistant/components/alexa_devices/switch.py

@@ -0,0 +1,84 @@
+"""Support for switches."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Final
+
+from aioamazondevices.api import AmazonDevice
+
+from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import AmazonConfigEntry
+from .entity import AmazonEntity
+
+PARALLEL_UPDATES = 1
+
+
+@dataclass(frozen=True, kw_only=True)
+class AmazonSwitchEntityDescription(SwitchEntityDescription):
+    """Alexa Devices switch entity description."""
+
+    is_on_fn: Callable[[AmazonDevice], bool]
+    subkey: str
+    method: str
+
+
+SWITCHES: Final = (
+    AmazonSwitchEntityDescription(
+        key="do_not_disturb",
+        subkey="AUDIO_PLAYER",
+        translation_key="do_not_disturb",
+        is_on_fn=lambda _device: _device.do_not_disturb,
+        method="set_do_not_disturb",
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AmazonConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Alexa Devices switches based on a config entry."""
+
+    coordinator = entry.runtime_data
+
+    async_add_entities(
+        AmazonSwitchEntity(coordinator, serial_num, switch_desc)
+        for switch_desc in SWITCHES
+        for serial_num in coordinator.data
+        if switch_desc.subkey in coordinator.data[serial_num].capabilities
+    )
+
+
+class AmazonSwitchEntity(AmazonEntity, SwitchEntity):
+    """Switch device."""
+
+    entity_description: AmazonSwitchEntityDescription
+
+    async def _switch_set_state(self, state: bool) -> None:
+        """Set desired switch state."""
+        method = getattr(self.coordinator.api, self.entity_description.method)
+
+        if TYPE_CHECKING:
+            assert method is not None
+
+        await method(self.device, state)
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the switch on."""
+        await self._switch_set_state(True)
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the switch off."""
+        await self._switch_set_state(False)
+
+    @property
+    def is_on(self) -> bool:
+        """Return True if switch is on."""
+        return self.entity_description.is_on_fn(self.device)

homeassistant/components/amcrest/__init__.py

@@ -16,10 +16,7 @@ from amcrest import AmcrestError, ApiWrapper, LoginError
 import httpx
 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,
     CONF_AUTHENTICATION,
     CONF_BINARY_SENSORS,
     CONF_HOST,
@@ -30,21 +27,17 @@ from homeassistant.const import (
     CONF_SENSORS,
     CONF_SWITCHES,
     CONF_USERNAME,
-    ENTITY_MATCH_ALL,
-    ENTITY_MATCH_NONE,
     HTTP_BASIC_AUTHENTICATION,
     Platform,
 )
-from homeassistant.core import HomeAssistant, ServiceCall, callback
-from homeassistant.exceptions import Unauthorized, UnknownUser
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import config_validation as cv, discovery
 from homeassistant.helpers.dispatcher import async_dispatcher_send, dispatcher_send
 from homeassistant.helpers.event import async_track_time_interval
-from homeassistant.helpers.service import async_extract_entity_ids
 from homeassistant.helpers.typing import ConfigType
 
 from .binary_sensor import BINARY_SENSOR_KEYS, BINARY_SENSORS, check_binary_sensors
-from .camera import CAMERA_SERVICES, STREAM_SOURCE_LIST
+from .camera import STREAM_SOURCE_LIST
 from .const import (
     CAMERAS,
     COMM_RETRIES,
@@ -58,6 +51,7 @@ from .const import (
 )
 from .helpers import service_signal
 from .sensor import SENSOR_KEYS
+from .services import async_setup_services
 from .switch import SWITCH_KEYS
 
 _LOGGER = logging.getLogger(__name__)
@@ -455,47 +449,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     if not hass.data[DATA_AMCREST][DEVICES]:
         return False
 
-    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(hass, 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])
+    async_setup_services(hass)
 
     return True
 

homeassistant/components/amcrest/services.py

@@ -0,0 +1,62 @@
+"""Support for Amcrest IP cameras."""
+
+from __future__ import annotations
+
+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 .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."""
+
+    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(hass, 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/analytics.py

@@ -24,7 +24,7 @@ from homeassistant.components.recorder import (
     get_instance as get_recorder_instance,
 )
 from homeassistant.config_entries import SOURCE_IGNORE
-from homeassistant.const import ATTR_DOMAIN, __version__ as HA_VERSION
+from homeassistant.const import ATTR_DOMAIN, BASE_PLATFORMS, __version__ as HA_VERSION
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import entity_registry as er
@@ -225,7 +225,8 @@ class Analytics:
                 LOGGER.error(err)
                 return
 
-            configuration_set = set(yaml_configuration)
+            configuration_set = _domains_from_yaml_config(yaml_configuration)
+
             er_platforms = {
                 entity.platform
                 for entity in ent_reg.entities.values()
@@ -370,3 +371,13 @@ class Analytics:
             for entry in entries
             if entry.source != SOURCE_IGNORE and entry.disabled_by is None
         )
+
+
+def _domains_from_yaml_config(yaml_configuration: dict[str, Any]) -> set[str]:
+    """Extract domains from the YAML configuration."""
+    domains = set(yaml_configuration)
+    for platforms in conf_util.extract_platform_integrations(
+        yaml_configuration, BASE_PLATFORMS
+    ).values():
+        domains.update(platforms)
+    return domains

homeassistant/components/androidtv_remote/manifest.json

@@ -7,6 +7,6 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["androidtvremote2"],
-  "requirements": ["androidtvremote2==0.2.1"],
+  "requirements": ["androidtvremote2==0.2.2"],
   "zeroconf": ["_androidtvremote2._tcp.local."]
 }

homeassistant/components/androidtv_remote/strings.json

@@ -51,6 +51,10 @@
           "app_id": "Application ID",
           "app_icon": "Application icon",
           "app_delete": "Check to delete this application"
+        },
+        "data_description": {
+          "app_id": "E.g. com.plexapp.android for https://play.google.com/store/apps/details?id=com.plexapp.android",
+          "app_icon": "Image URL. From the Play Store app page, right click on the icon and select 'Copy image address' and then paste it here. Alternatively, download the image, upload it under /config/www/ and use the URL /local/filename"
         }
       }
     }

homeassistant/components/anthropic/const.py

@@ -17,4 +17,11 @@ CONF_THINKING_BUDGET = "thinking_budget"
 RECOMMENDED_THINKING_BUDGET = 0
 MIN_THINKING_BUDGET = 1024
 
-THINKING_MODELS = ["claude-3-7-sonnet-20250219", "claude-3-7-sonnet-latest"]
+THINKING_MODELS = [
+    "claude-3-7-sonnet-20250219",
+    "claude-3-7-sonnet-latest",
+    "claude-opus-4-20250514",
+    "claude-opus-4-0",
+    "claude-sonnet-4-20250514",
+    "claude-sonnet-4-0",
+]

homeassistant/components/anthropic/conversation.py

@@ -294,6 +294,8 @@ async def _transform_stream(  # noqa: C901 - This is complex, but better to have
         elif isinstance(response, RawMessageDeltaEvent):
             if (usage := response.usage) is not None:
                 chat_log.async_trace(_create_token_stats(input_usage, usage))
+            if response.delta.stop_reason == "refusal":
+                raise HomeAssistantError("Potential policy violation detected")
         elif isinstance(response, RawMessageStopEvent):
             if current_message is not None:
                 messages.append(current_message)
@@ -326,6 +328,7 @@ class AnthropicConversationEntity(
 
     _attr_has_entity_name = True
     _attr_name = None
+    _attr_supports_streaming = True
 
     def __init__(self, entry: AnthropicConfigEntry) -> None:
         """Initialize the agent."""
@@ -363,15 +366,35 @@ class AnthropicConversationEntity(
         options = self.entry.options
 
         try:
-            await chat_log.async_update_llm_data(
-                DOMAIN,
-                user_input,
+            await chat_log.async_provide_llm_data(
+                user_input.as_llm_context(DOMAIN),
                 options.get(CONF_LLM_HASS_API),
                 options.get(CONF_PROMPT),
+                user_input.extra_system_prompt,
             )
         except conversation.ConverseError as err:
             return err.as_conversation_result()
 
+        await self._async_handle_chat_log(chat_log)
+
+        response_content = chat_log.content[-1]
+        if not isinstance(response_content, conversation.AssistantContent):
+            raise TypeError("Last message must be an assistant message")
+        intent_response = intent.IntentResponse(language=user_input.language)
+        intent_response.async_set_speech(response_content.content or "")
+        return conversation.ConversationResult(
+            response=intent_response,
+            conversation_id=chat_log.conversation_id,
+            continue_conversation=chat_log.continue_conversation,
+        )
+
+    async def _async_handle_chat_log(
+        self,
+        chat_log: conversation.ChatLog,
+    ) -> None:
+        """Generate an answer for the chat log."""
+        options = self.entry.options
+
         tools: list[ToolParam] | None = None
         if chat_log.llm_api:
             tools = [
@@ -421,7 +444,7 @@ class AnthropicConversationEntity(
                     [
                         content
                         async for content in chat_log.async_add_delta_content_stream(
-                            user_input.agent_id,
+                            self.entity_id,
                             _transform_stream(chat_log, stream, messages),
                         )
                         if not isinstance(content, conversation.AssistantContent)
@@ -432,17 +455,6 @@ class AnthropicConversationEntity(
             if not chat_log.unresponded_tool_results:
                 break
 
-        response_content = chat_log.content[-1]
-        if not isinstance(response_content, conversation.AssistantContent):
-            raise TypeError("Last message must be an assistant message")
-        intent_response = intent.IntentResponse(language=user_input.language)
-        intent_response.async_set_speech(response_content.content or "")
-        return conversation.ConversationResult(
-            response=intent_response,
-            conversation_id=chat_log.conversation_id,
-            continue_conversation=chat_log.continue_conversation,
-        )
-
     async def _async_entry_update_listener(
         self, hass: HomeAssistant, entry: ConfigEntry
     ) -> None:

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.47.2"]
+  "requirements": ["anthropic==0.52.0"]
 }

homeassistant/components/apcupsd/config_flow.py

@@ -46,11 +46,7 @@ class ConfigFlowHandler(ConfigFlow, domain=DOMAIN):
             return self.async_show_form(step_id="user", data_schema=_SCHEMA)
 
         host, port = user_input[CONF_HOST], user_input[CONF_PORT]
-
-        # Abort if an entry with same host and port is present.
         self._async_abort_entries_match({CONF_HOST: host, CONF_PORT: port})
-
-        # Test the connection to the host and get the current status for serial number.
         try:
             async with asyncio.timeout(CONNECTION_TIMEOUT):
                 data = APCUPSdData(await aioapcaccess.request_status(host, port))
@@ -67,3 +63,30 @@ class ConfigFlowHandler(ConfigFlow, domain=DOMAIN):
 
         title = data.name or data.model or data.serial_no or "APC UPS"
         return self.async_create_entry(title=title, data=user_input)
+
+    async def async_step_reconfigure(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reconfiguration of an existing entry."""
+
+        if user_input is None:
+            return self.async_show_form(step_id="reconfigure", data_schema=_SCHEMA)
+
+        host, port = user_input[CONF_HOST], user_input[CONF_PORT]
+        self._async_abort_entries_match({CONF_HOST: host, CONF_PORT: port})
+        try:
+            async with asyncio.timeout(CONNECTION_TIMEOUT):
+                data = APCUPSdData(await aioapcaccess.request_status(host, port))
+        except (OSError, asyncio.IncompleteReadError, TimeoutError):
+            errors = {"base": "cannot_connect"}
+            return self.async_show_form(
+                step_id="reconfigure", data_schema=_SCHEMA, errors=errors
+            )
+
+        await self.async_set_unique_id(data.serial_no)
+        self._abort_if_unique_id_mismatch(reason="wrong_apcupsd_daemon")
+
+        return self.async_update_reload_and_abort(
+            self._get_reconfigure_entry(),
+            data_updates=user_input,
+        )

homeassistant/components/apcupsd/strings.json

@@ -1,7 +1,9 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "wrong_apcupsd_daemon": "The reconfigured APC UPS Daemon is not the same as the one already configured.",
+      "reconfigure_successful": "[%key:common::config_flow::abort::reconfigure_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]"

homeassistant/components/aprilaire/humidifier.py

@@ -62,6 +62,8 @@ async def async_setup_entry(
                 target_humidity_key=Attribute.HUMIDIFICATION_SETPOINT,
                 min_humidity=10,
                 max_humidity=50,
+                auto_status_key=Attribute.HUMIDIFICATION_AVAILABLE,
+                auto_status_value=1,
                 default_humidity=30,
                 set_humidity_fn=coordinator.client.set_humidification_setpoint,
             )
@@ -77,6 +79,8 @@ async def async_setup_entry(
                 action_map=DEHUMIDIFIER_ACTION_MAP,
                 current_humidity_key=Attribute.INDOOR_HUMIDITY_CONTROLLING_SENSOR_VALUE,
                 target_humidity_key=Attribute.DEHUMIDIFICATION_SETPOINT,
+                auto_status_key=None,
+                auto_status_value=None,
                 min_humidity=40,
                 max_humidity=90,
                 default_humidity=60,
@@ -100,6 +104,8 @@ class AprilaireHumidifierDescription(HumidifierEntityDescription):
     target_humidity_key: str
     min_humidity: int
     max_humidity: int
+    auto_status_key: str | None
+    auto_status_value: int | None
     default_humidity: int
     set_humidity_fn: Callable[[int], Awaitable]
 
@@ -163,14 +169,31 @@ class AprilaireHumidifierEntity(BaseAprilaireEntity, HumidifierEntity):
     def min_humidity(self) -> float:
         """Return the minimum humidity."""
 
+        if self.is_auto_humidity_mode():
+            return 1
+
         return self.entity_description.min_humidity
 
     @property
     def max_humidity(self) -> float:
         """Return the maximum humidity."""
 
+        if self.is_auto_humidity_mode():
+            return 7
+
         return self.entity_description.max_humidity
 
+    def is_auto_humidity_mode(self) -> bool:
+        """Return whether the humidifier is in auto mode."""
+
+        if self.entity_description.auto_status_key is None:
+            return False
+
+        return (
+            self.coordinator.data.get(self.entity_description.auto_status_key)
+            == self.entity_description.auto_status_value
+        )
+
     async def async_set_humidity(self, humidity: int) -> None:
         """Set the humidity."""
 

homeassistant/components/aprilaire/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pyaprilaire"],
-  "requirements": ["pyaprilaire==0.8.1"]
+  "requirements": ["pyaprilaire==0.9.1"]
 }

homeassistant/components/apsystems/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["APsystemsEZ1"],
-  "requirements": ["apsystems-ez1==2.6.0"]
+  "requirements": ["apsystems-ez1==2.7.0"]
 }

homeassistant/components/aquacell/icons.json

@@ -1,6 +1,9 @@
 {
   "entity": {
     "sensor": {
+      "last_update": {
+        "default": "mdi:update"
+      },
       "salt_left_side_percentage": {
         "default": "mdi:basket-fill"
       },

homeassistant/components/aquacell/sensor.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from datetime import datetime
 
 from aioaquacell import Softener
 
@@ -28,7 +29,7 @@ PARALLEL_UPDATES = 1
 class SoftenerSensorEntityDescription(SensorEntityDescription):
     """Describes Softener sensor entity."""
 
-    value_fn: Callable[[Softener], StateType]
+    value_fn: Callable[[Softener], StateType | datetime]
 
 
 SENSORS: tuple[SoftenerSensorEntityDescription, ...] = (
@@ -77,6 +78,12 @@ SENSORS: tuple[SoftenerSensorEntityDescription, ...] = (
             "low",
         ],
     ),
+    SoftenerSensorEntityDescription(
+        key="last_update",
+        translation_key="last_update",
+        device_class=SensorDeviceClass.TIMESTAMP,
+        value_fn=lambda softener: softener.lastUpdate,
+    ),
 )
 
 
@@ -111,6 +118,6 @@ class SoftenerSensor(AquacellEntity, SensorEntity):
         self.entity_description = description
 
     @property
-    def native_value(self) -> StateType:
+    def native_value(self) -> StateType | datetime:
         """Return the state of the sensor."""
         return self.entity_description.value_fn(self.softener)

homeassistant/components/aquacell/strings.json

@@ -21,6 +21,9 @@
   },
   "entity": {
     "sensor": {
+      "last_update": {
+        "name": "Last update"
+      },
       "salt_left_side_percentage": {
         "name": "Salt left side percentage"
       },

homeassistant/components/aruba/device_tracker.py

@@ -89,7 +89,7 @@ class ArubaDeviceScanner(DeviceScanner):
     def get_aruba_data(self) -> dict[str, dict[str, str]] | None:
         """Retrieve data from Aruba Access Point and return parsed result."""
 
-        connect = f"ssh {self.username}@{self.host} -o HostKeyAlgorithms=ssh-rsa"
+        connect = f"ssh {self.username}@{self.host}"
         ssh: pexpect.spawn[str] = pexpect.spawn(connect, encoding="utf-8")
         query = ssh.expect(
             [

homeassistant/components/assist_pipeline/pipeline.py

@@ -20,9 +20,6 @@ import hass_nabucasa
 import voluptuous as vol
 
 from homeassistant.components import conversation, stt, tts, wake_word, websocket_api
-from homeassistant.components.tts import (
-    generate_media_source_id as tts_generate_media_source_id,
-)
 from homeassistant.const import ATTR_SUPPORTED_FEATURES, MATCH_ALL
 from homeassistant.core import Context, HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError
@@ -92,6 +89,8 @@ KEY_ASSIST_PIPELINE: HassKey[PipelineData] = HassKey(DOMAIN)
 KEY_PIPELINE_CONVERSATION_DATA: HassKey[dict[str, PipelineConversationData]] = HassKey(
     "pipeline_conversation_data"
 )
+# Number of response parts to handle before streaming the response
+STREAM_RESPONSE_CHARS = 60
 
 
 def validate_language(data: dict[str, Any]) -> Any:
@@ -555,7 +554,7 @@ class PipelineRun:
     event_callback: PipelineEventCallback
     language: str = None  # type: ignore[assignment]
     runner_data: Any | None = None
-    intent_agent: str | None = None
+    intent_agent: conversation.AgentInfo | None = None
     tts_audio_output: str | dict[str, Any] | None = None
     wake_word_settings: WakeWordSettings | None = None
     audio_settings: AudioSettings = field(default_factory=AudioSettings)
@@ -591,6 +590,9 @@ class PipelineRun:
     _intent_agent_only = False
     """If request should only be handled by agent, ignoring sentence triggers and local processing."""
 
+    _streamed_response_text = False
+    """If the conversation agent streamed response text to TTS result."""
+
     def __post_init__(self) -> None:
         """Set language for pipeline."""
         self.language = self.pipeline.language or self.hass.config.language
@@ -652,6 +654,11 @@ class PipelineRun:
                 "token": self.tts_stream.token,
                 "url": self.tts_stream.url,
                 "mime_type": self.tts_stream.content_type,
+                "stream_response": (
+                    self.tts_stream.supports_streaming_input
+                    and self.intent_agent
+                    and self.intent_agent.supports_streaming
+                ),
             }
 
         self.process_event(PipelineEvent(PipelineEventType.RUN_START, data))
@@ -899,12 +906,12 @@ class PipelineRun:
     ) -> str:
         """Run speech-to-text portion of pipeline. Returns the spoken text."""
         # Create a background task to prepare the conversation agent
-        if self.end_stage >= PipelineStage.INTENT:
+        if self.end_stage >= PipelineStage.INTENT and self.intent_agent:
             self.hass.async_create_background_task(
                 conversation.async_prepare_agent(
-                    self.hass, self.intent_agent, self.language
+                    self.hass, self.intent_agent.id, self.language
                 ),
-                f"prepare conversation agent {self.intent_agent}",
+                f"prepare conversation agent {self.intent_agent.id}",
             )
 
         if isinstance(self.stt_provider, stt.Provider):
@@ -1045,7 +1052,7 @@ class PipelineRun:
                     message=f"Intent recognition engine {engine} is not found",
                 )
 
-        self.intent_agent = agent_info.id
+        self.intent_agent = agent_info
 
     async def recognize_intent(
         self,
@@ -1078,7 +1085,7 @@ class PipelineRun:
             PipelineEvent(
                 PipelineEventType.INTENT_START,
                 {
-                    "engine": self.intent_agent,
+                    "engine": self.intent_agent.id,
                     "language": input_language,
                     "intent_input": intent_input,
                     "conversation_id": conversation_id,
@@ -1095,11 +1102,11 @@ class PipelineRun:
                 conversation_id=conversation_id,
                 device_id=device_id,
                 language=input_language,
-                agent_id=self.intent_agent,
+                agent_id=self.intent_agent.id,
                 extra_system_prompt=conversation_extra_system_prompt,
             )
 
-            agent_id = self.intent_agent
+            agent_id = self.intent_agent.id
             processed_locally = agent_id == conversation.HOME_ASSISTANT_AGENT
             intent_response: intent.IntentResponse | None = None
             if not processed_locally and not self._intent_agent_only:
@@ -1121,7 +1128,7 @@ class PipelineRun:
                 # If the LLM has API access, we filter out some sentences that are
                 # interfering with LLM operation.
                 if (
-                    intent_agent_state := self.hass.states.get(self.intent_agent)
+                    intent_agent_state := self.hass.states.get(self.intent_agent.id)
                 ) and intent_agent_state.attributes.get(
                     ATTR_SUPPORTED_FEATURES, 0
                 ) & conversation.ConversationEntityFeature.CONTROL:
@@ -1143,6 +1150,13 @@ class PipelineRun:
                     agent_id = conversation.HOME_ASSISTANT_AGENT
                     processed_locally = True
 
+            if self.tts_stream and self.tts_stream.supports_streaming_input:
+                tts_input_stream: asyncio.Queue[str | None] | None = asyncio.Queue()
+            else:
+                tts_input_stream = None
+            chat_log_role = None
+            delta_character_count = 0
+
             @callback
             def chat_log_delta_listener(
                 chat_log: conversation.ChatLog, delta: dict
@@ -1156,6 +1170,70 @@ class PipelineRun:
                         },
                     )
                 )
+                if tts_input_stream is None:
+                    return
+
+                nonlocal chat_log_role
+
+                if role := delta.get("role"):
+                    chat_log_role = role
+
+                # We are only interested in assistant deltas
+                if chat_log_role != "assistant":
+                    return
+
+                if content := delta.get("content"):
+                    tts_input_stream.put_nowait(content)
+
+                if self._streamed_response_text:
+                    return
+
+                nonlocal delta_character_count
+
+                # Streamed responses are not cached. That's why we only start streaming text after
+                # we have received enough characters that indicates it will be a long response
+                # or if we have received text, and then a tool call.
+
+                # Tool call after we already received text
+                start_streaming = delta_character_count > 0 and delta.get("tool_calls")
+
+                # Count characters in the content and test if we exceed streaming threshold
+                if not start_streaming and content:
+                    delta_character_count += len(content)
+                    start_streaming = delta_character_count > STREAM_RESPONSE_CHARS
+
+                if not start_streaming:
+                    return
+
+                self._streamed_response_text = True
+
+                self.process_event(
+                    PipelineEvent(
+                        PipelineEventType.INTENT_PROGRESS,
+                        {
+                            "tts_start_streaming": True,
+                        },
+                    )
+                )
+
+                async def tts_input_stream_generator() -> AsyncGenerator[str]:
+                    """Yield TTS input stream."""
+                    while (tts_input := await tts_input_stream.get()) is not None:
+                        yield tts_input
+
+                # Concatenate all existing queue items
+                parts = []
+                while not tts_input_stream.empty():
+                    parts.append(tts_input_stream.get_nowait())
+                tts_input_stream.put_nowait(
+                    "".join(
+                        # At this point parts is only strings, None indicates end of queue
+                        cast(list[str], parts)
+                    )
+                )
+
+                assert self.tts_stream is not None
+                self.tts_stream.async_set_message_stream(tts_input_stream_generator())
 
             with (
                 chat_session.async_get_chat_session(
@@ -1199,6 +1277,8 @@ class PipelineRun:
                     speech = conversation_result.response.speech.get("plain", {}).get(
                         "speech", ""
                     )
+                    if tts_input_stream and self._streamed_response_text:
+                        tts_input_stream.put_nowait(None)
 
         except Exception as src_error:
             _LOGGER.exception("Unexpected error during intent recognition")
@@ -1276,26 +1356,11 @@ class PipelineRun:
             )
         )
 
-        try:
-            # Synthesize audio and get URL
-            tts_media_id = tts_generate_media_source_id(
-                self.hass,
-                tts_input,
-                engine=self.tts_stream.engine,
-                language=self.tts_stream.language,
-                options=self.tts_stream.options,
-            )
-        except Exception as src_error:
-            _LOGGER.exception("Unexpected error during text-to-speech")
-            raise TextToSpeechError(
-                code="tts-failed",
-                message="Unexpected error during text-to-speech",
-            ) from src_error
-
-        self.tts_stream.async_set_message(tts_input)
+        if not self._streamed_response_text:
+            self.tts_stream.async_set_message(tts_input)
 
         tts_output = {
-            "media_id": tts_media_id,
+            "media_id": self.tts_stream.media_source_id,
             "token": self.tts_stream.token,
             "url": self.tts_stream.url,
             "mime_type": self.tts_stream.content_type,

homeassistant/components/atag/water_heater.py

@@ -6,6 +6,7 @@ from homeassistant.components.water_heater import (
     STATE_ECO,
     STATE_PERFORMANCE,
     WaterHeaterEntity,
+    WaterHeaterEntityFeature,
 )
 from homeassistant.const import ATTR_TEMPERATURE, STATE_OFF, Platform, UnitOfTemperature
 from homeassistant.core import HomeAssistant
@@ -32,6 +33,7 @@ class AtagWaterHeater(AtagEntity, WaterHeaterEntity):
     """Representation of an ATAG water heater."""
 
     _attr_operation_list = OPERATION_LIST
+    _attr_supported_features = WaterHeaterEntityFeature.TARGET_TEMPERATURE
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
 
     @property

homeassistant/components/axis/config_flow.py

@@ -47,7 +47,7 @@ from .const import (
     CONF_VIDEO_SOURCE,
     DEFAULT_STREAM_PROFILE,
     DEFAULT_VIDEO_SOURCE,
-    DOMAIN as AXIS_DOMAIN,
+    DOMAIN,
 )
 from .errors import AuthenticationRequired, CannotConnect
 from .hub import AxisHub, get_axis_api
@@ -58,7 +58,7 @@ DEFAULT_PROTOCOL = "https"
 PROTOCOL_CHOICES = ["https", "http"]
 
 
-class AxisFlowHandler(ConfigFlow, domain=AXIS_DOMAIN):
+class AxisFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a Axis config flow."""
 
     VERSION = 3
@@ -146,7 +146,7 @@ class AxisFlowHandler(ConfigFlow, domain=AXIS_DOMAIN):
         model = self.config[CONF_MODEL]
         same_model = [
             entry.data[CONF_NAME]
-            for entry in self.hass.config_entries.async_entries(AXIS_DOMAIN)
+            for entry in self.hass.config_entries.async_entries(DOMAIN)
             if entry.source != SOURCE_IGNORE and entry.data[CONF_MODEL] == model
         ]
 

homeassistant/components/axis/hub/hub.py

@@ -11,7 +11,7 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC, format_mac
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
-from ..const import ATTR_MANUFACTURER, DOMAIN as AXIS_DOMAIN
+from ..const import ATTR_MANUFACTURER, DOMAIN
 from .config import AxisConfig
 from .entity_loader import AxisEntityLoader
 from .event_source import AxisEventSource
@@ -79,7 +79,7 @@ class AxisHub:
             config_entry_id=self.config.entry.entry_id,
             configuration_url=self.api.config.url,
             connections={(CONNECTION_NETWORK_MAC, self.unique_id)},
-            identifiers={(AXIS_DOMAIN, self.unique_id)},
+            identifiers={(DOMAIN, self.unique_id)},
             manufacturer=ATTR_MANUFACTURER,
             model=f"{self.config.model} {self.product_type}",
             name=self.config.name,

homeassistant/components/azure_storage/__init__.py

@@ -2,8 +2,8 @@
 
 from aiohttp import ClientTimeout
 from azure.core.exceptions import (
+    AzureError,
     ClientAuthenticationError,
-    HttpResponseError,
     ResourceNotFoundError,
 )
 from azure.core.pipeline.transport._aiohttp import (
@@ -39,11 +39,20 @@ async def async_setup_entry(
     session = async_create_clientsession(
         hass, timeout=ClientTimeout(connect=10, total=12 * 60 * 60)
     )
-    container_client = ContainerClient(
-        account_url=f"https://{entry.data[CONF_ACCOUNT_NAME]}.blob.core.windows.net/",
-        container_name=entry.data[CONF_CONTAINER_NAME],
-        credential=entry.data[CONF_STORAGE_ACCOUNT_KEY],
-        transport=AioHttpTransport(session=session),
+
+    def create_container_client() -> ContainerClient:
+        """Create a ContainerClient."""
+
+        return ContainerClient(
+            account_url=f"https://{entry.data[CONF_ACCOUNT_NAME]}.blob.core.windows.net/",
+            container_name=entry.data[CONF_CONTAINER_NAME],
+            credential=entry.data[CONF_STORAGE_ACCOUNT_KEY],
+            transport=AioHttpTransport(session=session),
+        )
+
+    # has a blocking call to open in cpython
+    container_client: ContainerClient = await hass.async_add_executor_job(
+        create_container_client
     )
 
     try:
@@ -61,7 +70,7 @@ async def async_setup_entry(
             translation_key="invalid_auth",
             translation_placeholders={CONF_ACCOUNT_NAME: entry.data[CONF_ACCOUNT_NAME]},
         ) from err
-    except HttpResponseError as err:
+    except AzureError as err:
         raise ConfigEntryNotReady(
             translation_domain=DOMAIN,
             translation_key="cannot_connect",

homeassistant/components/azure_storage/backup.py

@@ -8,7 +8,7 @@ import json
 import logging
 from typing import Any, Concatenate
 
-from azure.core.exceptions import HttpResponseError
+from azure.core.exceptions import AzureError, HttpResponseError, ServiceRequestError
 from azure.storage.blob import BlobProperties
 
 from homeassistant.components.backup import (
@@ -80,6 +80,20 @@ def handle_backup_errors[_R, **P](
                 f"Error during backup operation in {func.__name__}:"
                 f" Status {err.status_code}, message: {err.message}"
             ) from err
+        except ServiceRequestError as err:
+            raise BackupAgentError(
+                f"Timeout during backup operation in {func.__name__}"
+            ) from err
+        except AzureError as err:
+            _LOGGER.debug(
+                "Error during backup in %s: %s",
+                func.__name__,
+                err,
+                exc_info=True,
+            )
+            raise BackupAgentError(
+                f"Error during backup operation in {func.__name__}: {err}"
+            ) from err
 
     return wrapper
 

homeassistant/components/azure_storage/config_flow.py

@@ -27,9 +27,25 @@ _LOGGER = logging.getLogger(__name__)
 class AzureStorageConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a config flow for azure storage."""
 
-    def get_account_url(self, account_name: str) -> str:
-        """Get the account URL."""
-        return f"https://{account_name}.blob.core.windows.net/"
+    async def get_container_client(
+        self, account_name: str, container_name: str, storage_account_key: str
+    ) -> ContainerClient:
+        """Get the container client.
+
+        ContainerClient has a blocking call to open in cpython
+        """
+
+        session = async_get_clientsession(self.hass)
+
+        def create_container_client() -> ContainerClient:
+            return ContainerClient(
+                account_url=f"https://{account_name}.blob.core.windows.net/",
+                container_name=container_name,
+                credential=storage_account_key,
+                transport=AioHttpTransport(session=session),
+            )
+
+        return await self.hass.async_add_executor_job(create_container_client)
 
     async def validate_config(
         self, container_client: ContainerClient
@@ -58,11 +74,10 @@ class AzureStorageConfigFlow(ConfigFlow, domain=DOMAIN):
             self._async_abort_entries_match(
                 {CONF_ACCOUNT_NAME: user_input[CONF_ACCOUNT_NAME]}
             )
-            container_client = ContainerClient(
-                account_url=self.get_account_url(user_input[CONF_ACCOUNT_NAME]),
+            container_client = await self.get_container_client(
+                account_name=user_input[CONF_ACCOUNT_NAME],
                 container_name=user_input[CONF_CONTAINER_NAME],
-                credential=user_input[CONF_STORAGE_ACCOUNT_KEY],
-                transport=AioHttpTransport(session=async_get_clientsession(self.hass)),
+                storage_account_key=user_input[CONF_STORAGE_ACCOUNT_KEY],
             )
             errors = await self.validate_config(container_client)
 
@@ -99,12 +114,12 @@ class AzureStorageConfigFlow(ConfigFlow, domain=DOMAIN):
         reauth_entry = self._get_reauth_entry()
 
         if user_input is not None:
-            container_client = ContainerClient(
-                account_url=self.get_account_url(reauth_entry.data[CONF_ACCOUNT_NAME]),
+            container_client = await self.get_container_client(
+                account_name=reauth_entry.data[CONF_ACCOUNT_NAME],
                 container_name=reauth_entry.data[CONF_CONTAINER_NAME],
-                credential=user_input[CONF_STORAGE_ACCOUNT_KEY],
-                transport=AioHttpTransport(session=async_get_clientsession(self.hass)),
+                storage_account_key=user_input[CONF_STORAGE_ACCOUNT_KEY],
             )
+
             errors = await self.validate_config(container_client)
             if not errors:
                 return self.async_update_reload_and_abort(
@@ -129,13 +144,10 @@ class AzureStorageConfigFlow(ConfigFlow, domain=DOMAIN):
         reconfigure_entry = self._get_reconfigure_entry()
 
         if user_input is not None:
-            container_client = ContainerClient(
-                account_url=self.get_account_url(
-                    reconfigure_entry.data[CONF_ACCOUNT_NAME]
-                ),
+            container_client = await self.get_container_client(
+                account_name=reconfigure_entry.data[CONF_ACCOUNT_NAME],
                 container_name=user_input[CONF_CONTAINER_NAME],
-                credential=user_input[CONF_STORAGE_ACCOUNT_KEY],
-                transport=AioHttpTransport(session=async_get_clientsession(self.hass)),
+                storage_account_key=user_input[CONF_STORAGE_ACCOUNT_KEY],
             )
             errors = await self.validate_config(container_client)
             if not errors:

homeassistant/components/backup/__init__.py

@@ -23,6 +23,7 @@ from .const import DATA_MANAGER, DOMAIN
 from .coordinator import BackupConfigEntry, BackupDataUpdateCoordinator
 from .http import async_register_http_views
 from .manager import (
+    AddonErrorData,
     BackupManager,
     BackupManagerError,
     BackupPlatformEvent,
@@ -48,6 +49,7 @@ from .util import suggested_filename, suggested_filename_from_name_date
 from .websocket import async_register_websocket_handlers
 
 __all__ = [
+    "AddonErrorData",
     "AddonInfo",
     "AgentBackup",
     "BackupAgent",
@@ -79,7 +81,7 @@ __all__ = [
     "suggested_filename_from_name_date",
 ]
 
-PLATFORMS = [Platform.SENSOR]
+PLATFORMS = [Platform.EVENT, Platform.SENSOR]
 
 CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 

homeassistant/components/backup/coordinator.py

@@ -33,6 +33,7 @@ class BackupCoordinatorData:
     last_attempted_automatic_backup: datetime | None
     last_successful_automatic_backup: datetime | None
     next_scheduled_automatic_backup: datetime | None
+    last_event: ManagerStateEvent | BackupPlatformEvent | None
 
 
 class BackupDataUpdateCoordinator(DataUpdateCoordinator[BackupCoordinatorData]):
@@ -60,11 +61,13 @@ class BackupDataUpdateCoordinator(DataUpdateCoordinator[BackupCoordinatorData]):
         ]
 
         self.backup_manager = backup_manager
+        self._last_event: ManagerStateEvent | BackupPlatformEvent | None = None
 
     @callback
     def _on_event(self, event: ManagerStateEvent | BackupPlatformEvent) -> None:
         """Handle new event."""
         LOGGER.debug("Received backup event: %s", event)
+        self._last_event = event
         self.config_entry.async_create_task(self.hass, self.async_refresh())
 
     async def _async_update_data(self) -> BackupCoordinatorData:
@@ -74,6 +77,7 @@ class BackupDataUpdateCoordinator(DataUpdateCoordinator[BackupCoordinatorData]):
             self.backup_manager.config.data.last_attempted_automatic_backup,
             self.backup_manager.config.data.last_completed_automatic_backup,
             self.backup_manager.config.data.schedule.next_automatic_backup,
+            self._last_event,
         )
 
     @callback

homeassistant/components/backup/entity.py

@@ -11,7 +11,7 @@ from .const import DOMAIN
 from .coordinator import BackupDataUpdateCoordinator
 
 
-class BackupManagerEntity(CoordinatorEntity[BackupDataUpdateCoordinator]):
+class BackupManagerBaseEntity(CoordinatorEntity[BackupDataUpdateCoordinator]):
     """Base entity for backup manager."""
 
     _attr_has_entity_name = True
@@ -19,12 +19,9 @@ class BackupManagerEntity(CoordinatorEntity[BackupDataUpdateCoordinator]):
     def __init__(
         self,
         coordinator: BackupDataUpdateCoordinator,
-        entity_description: EntityDescription,
     ) -> None:
         """Initialize base entity."""
         super().__init__(coordinator)
-        self.entity_description = entity_description
-        self._attr_unique_id = entity_description.key
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, "backup_manager")},
             manufacturer="Home Assistant",
@@ -34,3 +31,17 @@ class BackupManagerEntity(CoordinatorEntity[BackupDataUpdateCoordinator]):
             entry_type=DeviceEntryType.SERVICE,
             configuration_url="homeassistant://config/backup",
         )
+
+
+class BackupManagerEntity(BackupManagerBaseEntity):
+    """Entity for backup manager."""
+
+    def __init__(
+        self,
+        coordinator: BackupDataUpdateCoordinator,
+        entity_description: EntityDescription,
+    ) -> None:
+        """Initialize entity."""
+        super().__init__(coordinator)
+        self.entity_description = entity_description
+        self._attr_unique_id = entity_description.key

homeassistant/components/backup/event.py

@@ -0,0 +1,59 @@
+"""Event platform for Home Assistant Backup integration."""
+
+from __future__ import annotations
+
+from typing import Final
+
+from homeassistant.components.event import EventEntity
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import BackupConfigEntry, BackupDataUpdateCoordinator
+from .entity import BackupManagerBaseEntity
+from .manager import CreateBackupEvent, CreateBackupState
+
+ATTR_BACKUP_STAGE: Final[str] = "backup_stage"
+ATTR_FAILED_REASON: Final[str] = "failed_reason"
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BackupConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Event set up for backup config entry."""
+    coordinator = config_entry.runtime_data
+    async_add_entities([AutomaticBackupEvent(coordinator)])
+
+
+class AutomaticBackupEvent(BackupManagerBaseEntity, EventEntity):
+    """Representation of an automatic backup event."""
+
+    _attr_event_types = [s.value for s in CreateBackupState]
+    _unrecorded_attributes = frozenset({ATTR_FAILED_REASON, ATTR_BACKUP_STAGE})
+    coordinator: BackupDataUpdateCoordinator
+
+    def __init__(self, coordinator: BackupDataUpdateCoordinator) -> None:
+        """Initialize the automatic backup event."""
+        super().__init__(coordinator)
+        self._attr_unique_id = "automatic_backup_event"
+        self._attr_translation_key = "automatic_backup_event"
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        if (
+            not (data := self.coordinator.data)
+            or (event := data.last_event) is None
+            or not isinstance(event, CreateBackupEvent)
+        ):
+            return
+
+        self._trigger_event(
+            event.state,
+            {
+                ATTR_BACKUP_STAGE: event.stage,
+                ATTR_FAILED_REASON: event.reason,
+            },
+        )
+        self.async_write_ha_state()

homeassistant/components/backup/icons.json

@@ -1,4 +1,11 @@
 {
+  "entity": {
+    "event": {
+      "automatic_backup_event": {
+        "default": "mdi:database"
+      }
+    }
+  },
   "services": {
     "create": {
       "service": "mdi:cloud-upload"

homeassistant/components/backup/manager.py

@@ -62,6 +62,7 @@ from .const import (
     LOGGER,
 )
 from .models import (
+    AddonInfo,
     AgentBackup,
     BackupError,
     BackupManagerError,
@@ -102,15 +103,27 @@ class ManagerBackup(BaseBackup):
     """Backup class."""
 
     agents: dict[str, AgentBackupStatus]
+    failed_addons: list[AddonInfo]
     failed_agent_ids: list[str]
+    failed_folders: list[Folder]
     with_automatic_settings: bool | None
 
 
+@dataclass(frozen=True, kw_only=True, slots=True)
+class AddonErrorData:
+    """Addon error class."""
+
+    addon: AddonInfo
+    errors: list[tuple[str, str]]
+
+
 @dataclass(frozen=True, kw_only=True, slots=True)
 class WrittenBackup:
     """Written backup class."""
 
+    addon_errors: dict[str, AddonErrorData]
     backup: AgentBackup
+    folder_errors: dict[Folder, list[tuple[str, str]]]
     open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]]
     release_stream: Callable[[], Coroutine[Any, Any, None]]
 
@@ -636,9 +649,13 @@ class BackupManager:
             for agent_backup in result:
                 if (backup_id := agent_backup.backup_id) not in backups:
                     if known_backup := self.known_backups.get(backup_id):
+                        failed_addons = known_backup.failed_addons
                         failed_agent_ids = known_backup.failed_agent_ids
+                        failed_folders = known_backup.failed_folders
                     else:
+                        failed_addons = []
                         failed_agent_ids = []
+                        failed_folders = []
                     with_automatic_settings = self.is_our_automatic_backup(
                         agent_backup, await instance_id.async_get(self.hass)
                     )
@@ -649,7 +666,9 @@ class BackupManager:
                         date=agent_backup.date,
                         database_included=agent_backup.database_included,
                         extra_metadata=agent_backup.extra_metadata,
+                        failed_addons=failed_addons,
                         failed_agent_ids=failed_agent_ids,
+                        failed_folders=failed_folders,
                         folders=agent_backup.folders,
                         homeassistant_included=agent_backup.homeassistant_included,
                         homeassistant_version=agent_backup.homeassistant_version,
@@ -704,9 +723,13 @@ class BackupManager:
                 continue
             if backup is None:
                 if known_backup := self.known_backups.get(backup_id):
+                    failed_addons = known_backup.failed_addons
                     failed_agent_ids = known_backup.failed_agent_ids
+                    failed_folders = known_backup.failed_folders
                 else:
+                    failed_addons = []
                     failed_agent_ids = []
+                    failed_folders = []
                 with_automatic_settings = self.is_our_automatic_backup(
                     result, await instance_id.async_get(self.hass)
                 )
@@ -717,7 +740,9 @@ class BackupManager:
                     date=result.date,
                     database_included=result.database_included,
                     extra_metadata=result.extra_metadata,
+                    failed_addons=failed_addons,
                     failed_agent_ids=failed_agent_ids,
+                    failed_folders=failed_folders,
                     folders=result.folders,
                     homeassistant_included=result.homeassistant_included,
                     homeassistant_version=result.homeassistant_version,
@@ -960,7 +985,7 @@ class BackupManager:
             password=None,
         )
         await written_backup.release_stream()
-        self.known_backups.add(written_backup.backup, agent_errors, [])
+        self.known_backups.add(written_backup.backup, agent_errors, {}, {}, [])
         return written_backup.backup.backup_id
 
     async def async_create_backup(
@@ -1198,7 +1223,11 @@ class BackupManager:
             finally:
                 await written_backup.release_stream()
             self.known_backups.add(
-                written_backup.backup, agent_errors, unavailable_agents
+                written_backup.backup,
+                agent_errors,
+                written_backup.addon_errors,
+                written_backup.folder_errors,
+                unavailable_agents,
             )
             if not agent_errors:
                 if with_automatic_settings:
@@ -1208,7 +1237,9 @@ class BackupManager:
                 backup_success = True
 
             if with_automatic_settings:
-                self._update_issue_after_agent_upload(agent_errors, unavailable_agents)
+                self._update_issue_after_agent_upload(
+                    written_backup, agent_errors, unavailable_agents
+                )
             # delete old backups more numerous than copies
             # try this regardless of agent errors above
             await delete_backups_exceeding_configured_count(self)
@@ -1354,8 +1385,10 @@ class BackupManager:
         for subscription in self._backup_event_subscriptions:
             subscription(event)
 
-    def _update_issue_backup_failed(self) -> None:
-        """Update issue registry when a backup fails."""
+    def _create_automatic_backup_failed_issue(
+        self, translation_key: str, translation_placeholders: dict[str, str] | None
+    ) -> None:
+        """Create an issue in the issue registry for automatic backup failures."""
         ir.async_create_issue(
             self.hass,
             DOMAIN,
@@ -1364,37 +1397,73 @@ class BackupManager:
             is_persistent=True,
             learn_more_url="homeassistant://config/backup",
             severity=ir.IssueSeverity.WARNING,
-            translation_key="automatic_backup_failed_create",
+            translation_key=translation_key,
+            translation_placeholders=translation_placeholders,
+        )
+
+    def _update_issue_backup_failed(self) -> None:
+        """Update issue registry when a backup fails."""
+        self._create_automatic_backup_failed_issue(
+            "automatic_backup_failed_create", None
         )
 
     def _update_issue_after_agent_upload(
-        self, agent_errors: dict[str, Exception], unavailable_agents: list[str]
+        self,
+        written_backup: WrittenBackup,
+        agent_errors: dict[str, Exception],
+        unavailable_agents: list[str],
     ) -> None:
         """Update issue registry after a backup is uploaded to agents."""
-        if not agent_errors and not unavailable_agents:
+
+        addon_errors = written_backup.addon_errors
+        failed_agents = unavailable_agents + [
+            self.backup_agents[agent_id].name for agent_id in agent_errors
+        ]
+        folder_errors = written_backup.folder_errors
+
+        if not failed_agents and not addon_errors and not folder_errors:
+            # No issues to report, clear previous error
             ir.async_delete_issue(self.hass, DOMAIN, "automatic_backup_failed")
             return
-        ir.async_create_issue(
-            self.hass,
-            DOMAIN,
-            "automatic_backup_failed",
-            is_fixable=False,
-            is_persistent=True,
-            learn_more_url="homeassistant://config/backup",
-            severity=ir.IssueSeverity.WARNING,
-            translation_key="automatic_backup_failed_upload_agents",
-            translation_placeholders={
-                "failed_agents": ", ".join(
-                    chain(
-                        (
-                            self.backup_agents[agent_id].name
-                            for agent_id in agent_errors
-                        ),
-                        unavailable_agents,
+        if failed_agents and not (addon_errors or folder_errors):
+            # No issues with add-ons or folders, but issues with agents
+            self._create_automatic_backup_failed_issue(
+                "automatic_backup_failed_upload_agents",
+                {"failed_agents": ", ".join(failed_agents)},
+            )
+        elif addon_errors and not (failed_agents or folder_errors):
+            # No issues with agents or folders, but issues with add-ons
+            self._create_automatic_backup_failed_issue(
+                "automatic_backup_failed_addons",
+                {
+                    "failed_addons": ", ".join(
+                        val.addon.name or val.addon.slug
+                        for val in addon_errors.values()
                     )
-                )
-            },
-        )
+                },
+            )
+        elif folder_errors and not (failed_agents or addon_errors):
+            # No issues with agents or add-ons, but issues with folders
+            self._create_automatic_backup_failed_issue(
+                "automatic_backup_failed_folders",
+                {"failed_folders": ", ".join(folder for folder in folder_errors)},
+            )
+        else:
+            # Issues with agents, add-ons, and/or folders
+            self._create_automatic_backup_failed_issue(
+                "automatic_backup_failed_agents_addons_folders",
+                {
+                    "failed_agents": ", ".join(failed_agents) or "-",
+                    "failed_addons": (
+                        ", ".join(
+                            val.addon.name or val.addon.slug
+                            for val in addon_errors.values()
+                        )
+                        or "-"
+                    ),
+                    "failed_folders": ", ".join(f for f in folder_errors) or "-",
+                },
+            )
 
     async def async_can_decrypt_on_download(
         self,
@@ -1460,7 +1529,12 @@ class KnownBackups:
         self._backups = {
             backup["backup_id"]: KnownBackup(
                 backup_id=backup["backup_id"],
+                failed_addons=[
+                    AddonInfo(name=a["name"], slug=a["slug"], version=a["version"])
+                    for a in backup["failed_addons"]
+                ],
                 failed_agent_ids=backup["failed_agent_ids"],
+                failed_folders=[Folder(f) for f in backup["failed_folders"]],
             )
             for backup in stored_backups
         }
@@ -1473,12 +1547,16 @@ class KnownBackups:
         self,
         backup: AgentBackup,
         agent_errors: dict[str, Exception],
+        failed_addons: dict[str, AddonErrorData],
+        failed_folders: dict[Folder, list[tuple[str, str]]],
         unavailable_agents: list[str],
     ) -> None:
         """Add a backup."""
         self._backups[backup.backup_id] = KnownBackup(
             backup_id=backup.backup_id,
+            failed_addons=[val.addon for val in failed_addons.values()],
             failed_agent_ids=list(chain(agent_errors, unavailable_agents)),
+            failed_folders=list(failed_folders),
         )
         self._manager.store.save()
 
@@ -1499,21 +1577,38 @@ class KnownBackup:
     """Persistent backup data."""
 
     backup_id: str
+    failed_addons: list[AddonInfo]
     failed_agent_ids: list[str]
+    failed_folders: list[Folder]
 
     def to_dict(self) -> StoredKnownBackup:
         """Convert known backup to a dict."""
         return {
             "backup_id": self.backup_id,
+            "failed_addons": [
+                {"name": a.name, "slug": a.slug, "version": a.version}
+                for a in self.failed_addons
+            ],
             "failed_agent_ids": self.failed_agent_ids,
+            "failed_folders": [f.value for f in self.failed_folders],
         }
 
 
+class StoredAddonInfo(TypedDict):
+    """Stored add-on info."""
+
+    name: str | None
+    slug: str
+    version: str | None
+
+
 class StoredKnownBackup(TypedDict):
     """Stored persistent backup data."""
 
     backup_id: str
+    failed_addons: list[StoredAddonInfo]
     failed_agent_ids: list[str]
+    failed_folders: list[str]
 
 
 class CoreBackupReaderWriter(BackupReaderWriter):
@@ -1677,7 +1772,11 @@ class CoreBackupReaderWriter(BackupReaderWriter):
                     raise BackupReaderWriterError(str(err)) from err
 
             return WrittenBackup(
-                backup=backup, open_stream=open_backup, release_stream=remove_backup
+                addon_errors={},
+                backup=backup,
+                folder_errors={},
+                open_stream=open_backup,
+                release_stream=remove_backup,
             )
         finally:
             # Inform integrations the backup is done
@@ -1816,7 +1915,11 @@ class CoreBackupReaderWriter(BackupReaderWriter):
             await async_add_executor_job(temp_file.unlink, True)
 
         return WrittenBackup(
-            backup=backup, open_stream=open_backup, release_stream=remove_backup
+            addon_errors={},
+            backup=backup,
+            folder_errors={},
+            open_stream=open_backup,
+            release_stream=remove_backup,
         )
 
     async def async_restore_backup(

homeassistant/components/backup/models.py

@@ -13,9 +13,9 @@ from homeassistant.exceptions import HomeAssistantError
 class AddonInfo:
     """Addon information."""
 
-    name: str
+    name: str | None
     slug: str
-    version: str
+    version: str | None
 
 
 class Folder(StrEnum):

homeassistant/components/backup/store.py

@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 STORE_DELAY_SAVE = 30
 STORAGE_KEY = DOMAIN
 STORAGE_VERSION = 1
-STORAGE_VERSION_MINOR = 6
+STORAGE_VERSION_MINOR = 7
 
 
 class StoredBackupData(TypedDict):
@@ -76,8 +76,16 @@ class _BackupStore(Store[StoredBackupData]):
                 # Version 1.6 adds agent retention settings
                 for agent in data["config"]["agents"]:
                     data["config"]["agents"][agent]["retention"] = None
+            if old_minor_version < 7:
+                # Version 1.7 adds failing addons and folders
+                for backup in data["backups"]:
+                    backup["failed_addons"] = []
+                    backup["failed_folders"] = []
 
-        # Note: We allow reading data with major version 2.
+        # Note: We allow reading data with major version 2 in which the unused key
+        # data["config"]["schedule"]["state"] will be removed. The bump to 2 is
+        # planned to happen after a 6 month quiet period with no minor version
+        # changes.
         # Reject if major version is higher than 2.
         if old_major_version > 2:
             raise NotImplementedError

homeassistant/components/backup/strings.json

@@ -11,6 +11,18 @@
     "automatic_backup_failed_upload_agents": {
       "title": "Automatic backup could not be uploaded to the configured locations",
       "description": "The automatic backup could not be uploaded to the configured locations {failed_agents}. Please check the logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured."
+    },
+    "automatic_backup_failed_addons": {
+      "title": "Not all add-ons could be included in automatic backup",
+      "description": "Add-ons {failed_addons} could not be included in automatic backup. Please check the supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured."
+    },
+    "automatic_backup_failed_agents_addons_folders": {
+      "title": "Automatic backup was created with errors",
+      "description": "The automatic backup was created with errors:\n* Locations which the backup could not be uploaded to: {failed_agents}\n* Add-ons which could not be backed up: {failed_addons}\n* Folders which could not be backed up: {failed_folders}\n\nPlease check the core and supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured."
+    },
+    "automatic_backup_failed_folders": {
+      "title": "Not all folders could be included in automatic backup",
+      "description": "Folders {failed_folders} could not be included in automatic backup. Please check the supervisor logs for more information. Another attempt will be made at the next scheduled time if a backup schedule is configured."
     }
   },
   "services": {
@@ -24,6 +36,22 @@
     }
   },
   "entity": {
+    "event": {
+      "automatic_backup_event": {
+        "name": "Automatic backup",
+        "state_attributes": {
+          "event_type": {
+            "state": {
+              "completed": "Completed successfully",
+              "failed": "Failed",
+              "in_progress": "In progress"
+            }
+          },
+          "backup_stage": { "name": "Backup stage" },
+          "failed_reason": { "name": "Failure reason" }
+        }
+      }
+    },
     "sensor": {
       "backup_manager_state": {
         "name": "Backup Manager state",

homeassistant/components/blebox/climate.py

@@ -21,7 +21,6 @@ from .entity import BleBoxEntity
 SCAN_INTERVAL = timedelta(seconds=5)
 
 BLEBOX_TO_HVACMODE = {
-    None: None,
     0: HVACMode.OFF,
     1: HVACMode.HEAT,
     2: HVACMode.COOL,
@@ -59,12 +58,14 @@ class BleBoxClimateEntity(BleBoxEntity[blebox_uniapi.climate.Climate], ClimateEn
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
 
     @property
-    def hvac_modes(self):
+    def hvac_modes(self) -> list[HVACMode]:
         """Return list of supported HVAC modes."""
+        if self._feature.mode is None:
+            return [HVACMode.OFF]
         return [HVACMode.OFF, BLEBOX_TO_HVACMODE[self._feature.mode]]
 
     @property
-    def hvac_mode(self):
+    def hvac_mode(self) -> HVACMode | None:
         """Return the desired HVAC mode."""
         if self._feature.is_on is None:
             return None
@@ -75,7 +76,7 @@ class BleBoxClimateEntity(BleBoxEntity[blebox_uniapi.climate.Climate], ClimateEn
         return HVACMode.HEAT if self._feature.is_on else HVACMode.OFF
 
     @property
-    def hvac_action(self):
+    def hvac_action(self) -> HVACAction | None:
         """Return the actual current HVAC action."""
         if self._feature.hvac_action is not None:
             if not self._feature.is_on:
@@ -88,22 +89,22 @@ class BleBoxClimateEntity(BleBoxEntity[blebox_uniapi.climate.Climate], ClimateEn
         return HVACAction.HEATING if self._feature.is_heating else HVACAction.IDLE
 
     @property
-    def max_temp(self):
+    def max_temp(self) -> float:
         """Return the maximum temperature supported."""
         return self._feature.max_temp
 
     @property
-    def min_temp(self):
+    def min_temp(self) -> float:
         """Return the maximum temperature supported."""
         return self._feature.min_temp
 
     @property
-    def current_temperature(self):
+    def current_temperature(self) -> float | None:
         """Return the current temperature."""
         return self._feature.current
 
     @property
-    def target_temperature(self):
+    def target_temperature(self) -> float | None:
         """Return the desired thermostat temperature."""
         return self._feature.desired
 

homeassistant/components/blebox/light.py

@@ -84,7 +84,7 @@ class BleBoxLightEntity(BleBoxEntity[blebox_uniapi.light.Light], LightEntity):
         return color_util.color_temperature_mired_to_kelvin(self._feature.color_temp)
 
     @property
-    def color_mode(self):
+    def color_mode(self) -> ColorMode:
         """Return the color mode.
 
         Set values to _attr_ibutes if needed.
@@ -92,7 +92,7 @@ class BleBoxLightEntity(BleBoxEntity[blebox_uniapi.light.Light], LightEntity):
         return COLOR_MODE_MAP.get(self._feature.color_mode, ColorMode.ONOFF)
 
     @property
-    def supported_color_modes(self):
+    def supported_color_modes(self) -> set[ColorMode]:
         """Return supported color modes."""
         return {self.color_mode}
 
@@ -107,7 +107,7 @@ class BleBoxLightEntity(BleBoxEntity[blebox_uniapi.light.Light], LightEntity):
         return self._feature.effect
 
     @property
-    def rgb_color(self):
+    def rgb_color(self) -> tuple[int, int, int] | None:
         """Return value for rgb."""
         if (rgb_hex := self._feature.rgb_hex) is None:
             return None
@@ -118,14 +118,14 @@ class BleBoxLightEntity(BleBoxEntity[blebox_uniapi.light.Light], LightEntity):
         )
 
     @property
-    def rgbw_color(self):
+    def rgbw_color(self) -> tuple[int, int, int, int] | None:
         """Return the hue and saturation."""
         if (rgbw_hex := self._feature.rgbw_hex) is None:
             return None
         return tuple(blebox_uniapi.light.Light.rgb_hex_to_rgb_list(rgbw_hex)[0:4])
 
     @property
-    def rgbww_color(self):
+    def rgbww_color(self) -> tuple[int, int, int, int, int] | None:
         """Return value for rgbww."""
         if (rgbww_hex := self._feature.rgbww_hex) is None:
             return None

homeassistant/components/blink/__init__.py

@@ -25,7 +25,7 @@ from homeassistant.helpers.typing import ConfigType
 
 from .const import DEFAULT_SCAN_INTERVAL, DOMAIN, PLATFORMS
 from .coordinator import BlinkConfigEntry, BlinkUpdateCoordinator
-from .services import setup_services
+from .services import async_setup_services
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -72,7 +72,7 @@ async def async_migrate_entry(hass: HomeAssistant, entry: BlinkConfigEntry) -> b
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up Blink."""
 
-    setup_services(hass)
+    async_setup_services(hass)
 
     return True
 

homeassistant/components/blink/services.py

@@ -6,7 +6,7 @@ import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.const import CONF_PIN
-from homeassistant.core import HomeAssistant, ServiceCall
+from homeassistant.core import HomeAssistant, ServiceCall, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import config_validation as cv
 
@@ -21,34 +21,36 @@ SERVICE_SEND_PIN_SCHEMA = vol.Schema(
 )
 
 
-def setup_services(hass: HomeAssistant) -> None:
-    """Set up the services for the Blink integration."""
-
-    async def send_pin(call: ServiceCall):
-        """Call blink to send new pin."""
-        config_entry: BlinkConfigEntry | None
-        for entry_id in call.data[ATTR_CONFIG_ENTRY_ID]:
-            if not (config_entry := hass.config_entries.async_get_entry(entry_id)):
-                raise ServiceValidationError(
-                    translation_domain=DOMAIN,
-                    translation_key="integration_not_found",
-                    translation_placeholders={"target": DOMAIN},
-                )
-            if config_entry.state != ConfigEntryState.LOADED:
-                raise HomeAssistantError(
-                    translation_domain=DOMAIN,
-                    translation_key="not_loaded",
-                    translation_placeholders={"target": config_entry.title},
-                )
-            coordinator = config_entry.runtime_data
-            await coordinator.api.auth.send_auth_key(
-                coordinator.api,
-                call.data[CONF_PIN],
+async def _send_pin(call: ServiceCall) -> None:
+    """Call blink to send new pin."""
+    config_entry: BlinkConfigEntry | None
+    for entry_id in call.data[ATTR_CONFIG_ENTRY_ID]:
+        if not (config_entry := call.hass.config_entries.async_get_entry(entry_id)):
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="integration_not_found",
+                translation_placeholders={"target": DOMAIN},
             )
+        if config_entry.state != ConfigEntryState.LOADED:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="not_loaded",
+                translation_placeholders={"target": config_entry.title},
+            )
+        coordinator = config_entry.runtime_data
+        await coordinator.api.auth.send_auth_key(
+            coordinator.api,
+            call.data[CONF_PIN],
+        )
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Set up the services for the Blink integration."""
 
     hass.services.async_register(
         DOMAIN,
         SERVICE_SEND_PIN,
-        send_pin,
+        _send_pin,
         schema=SERVICE_SEND_PIN_SCHEMA,
     )

homeassistant/components/blue_current/__init__.py

@@ -24,7 +24,7 @@ from .const import DOMAIN, EVSE_ID, LOGGER, MODEL_TYPE
 
 type BlueCurrentConfigEntry = ConfigEntry[Connector]
 
-PLATFORMS = [Platform.SENSOR]
+PLATFORMS = [Platform.BUTTON, Platform.SENSOR]
 CHARGE_POINTS = "CHARGE_POINTS"
 DATA = "data"
 DELAY = 5

homeassistant/components/blue_current/button.py

@@ -0,0 +1,89 @@
+"""Support for Blue Current buttons."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Coroutine
+from dataclasses import dataclass
+from typing import Any
+
+from bluecurrent_api.client import Client
+
+from homeassistant.components.button import (
+    ButtonDeviceClass,
+    ButtonEntity,
+    ButtonEntityDescription,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BlueCurrentConfigEntry, Connector
+from .entity import ChargepointEntity
+
+
+@dataclass(kw_only=True, frozen=True)
+class ChargePointButtonEntityDescription(ButtonEntityDescription):
+    """Describes a Blue Current button entity."""
+
+    function: Callable[[Client, str], Coroutine[Any, Any, None]]
+
+
+CHARGE_POINT_BUTTONS = (
+    ChargePointButtonEntityDescription(
+        key="reset",
+        translation_key="reset",
+        function=lambda client, evse_id: client.reset(evse_id),
+        device_class=ButtonDeviceClass.RESTART,
+    ),
+    ChargePointButtonEntityDescription(
+        key="reboot",
+        translation_key="reboot",
+        function=lambda client, evse_id: client.reboot(evse_id),
+        device_class=ButtonDeviceClass.RESTART,
+    ),
+    ChargePointButtonEntityDescription(
+        key="stop_charge_session",
+        translation_key="stop_charge_session",
+        function=lambda client, evse_id: client.stop_session(evse_id),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: BlueCurrentConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Blue Current buttons."""
+    connector: Connector = entry.runtime_data
+    async_add_entities(
+        ChargePointButton(
+            connector,
+            button,
+            evse_id,
+        )
+        for evse_id in connector.charge_points
+        for button in CHARGE_POINT_BUTTONS
+    )
+
+
+class ChargePointButton(ChargepointEntity, ButtonEntity):
+    """Define a charge point button."""
+
+    has_value = True
+    entity_description: ChargePointButtonEntityDescription
+
+    def __init__(
+        self,
+        connector: Connector,
+        description: ChargePointButtonEntityDescription,
+        evse_id: str,
+    ) -> None:
+        """Initialize the button."""
+        super().__init__(connector, evse_id)
+
+        self.entity_description = description
+        self._attr_unique_id = f"{description.key}_{evse_id}"
+
+    async def async_press(self) -> None:
+        """Handle the button press."""
+        await self.entity_description.function(self.connector.client, self.evse_id)

homeassistant/components/blue_current/entity.py

@@ -1,7 +1,5 @@
 """Entity representing a Blue Current charge point."""
 
-from abc import abstractmethod
-
 from homeassistant.const import ATTR_NAME
 from homeassistant.core import callback
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -17,12 +15,12 @@ class BlueCurrentEntity(Entity):
 
     _attr_has_entity_name = True
     _attr_should_poll = False
+    has_value = False
 
     def __init__(self, connector: Connector, signal: str) -> None:
         """Initialize the entity."""
         self.connector = connector
         self.signal = signal
-        self.has_value = False
 
     async def async_added_to_hass(self) -> None:
         """Register callbacks."""
@@ -43,7 +41,6 @@ class BlueCurrentEntity(Entity):
         return self.connector.connected and self.has_value
 
     @callback
-    @abstractmethod
     def update_from_latest_data(self) -> None:
         """Update the entity from the latest data."""
 

homeassistant/components/blue_current/icons.json

@@ -19,6 +19,17 @@
       "current_left": {
         "default": "mdi:gauge"
       }
+    },
+    "button": {
+      "reset": {
+        "default": "mdi:restart"
+      },
+      "reboot": {
+        "default": "mdi:restart-alert"
+      },
+      "stop_charge_session": {
+        "default": "mdi:stop"
+      }
     }
   }
 }

homeassistant/components/blue_current/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "blue_current",
   "name": "Blue Current",
-  "codeowners": ["@Floris272", "@gleeuwen"],
+  "codeowners": ["@gleeuwen", "@NickKoepr", "@jtodorova23"],
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/blue_current",
   "iot_class": "cloud_push",

homeassistant/components/blue_current/strings.json

@@ -113,6 +113,17 @@
       "grid_max_current": {
         "name": "Max grid current"
       }
+    },
+    "button": {
+      "stop_charge_session": {
+        "name": "Stop charge session"
+      },
+      "reboot": {
+        "name": "Reboot"
+      },
+      "reset": {
+        "name": "Reset"
+      }
     }
   }
 }

homeassistant/components/bluetooth/manifest.json

@@ -18,9 +18,9 @@
     "bleak==0.22.3",
     "bleak-retry-connector==3.9.0",
     "bluetooth-adapters==0.21.4",
-    "bluetooth-auto-recovery==1.5.1",
+    "bluetooth-auto-recovery==1.5.2",
     "bluetooth-data-tools==1.28.1",
     "dbus-fast==2.43.0",
-    "habluetooth==3.48.2"
+    "habluetooth==3.49.0"
   ]
 }

homeassistant/components/bmw_connected_drive/coordinator.py

@@ -22,13 +22,7 @@ from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util.ssl import get_default_context
 
-from .const import (
-    CONF_GCID,
-    CONF_READ_ONLY,
-    CONF_REFRESH_TOKEN,
-    DOMAIN as BMW_DOMAIN,
-    SCAN_INTERVALS,
-)
+from .const import CONF_GCID, CONF_READ_ONLY, CONF_REFRESH_TOKEN, DOMAIN, SCAN_INTERVALS
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -63,7 +57,7 @@ class BMWDataUpdateCoordinator(DataUpdateCoordinator[None]):
             hass,
             _LOGGER,
             config_entry=config_entry,
-            name=f"{BMW_DOMAIN}-{config_entry.data[CONF_USERNAME]}",
+            name=f"{DOMAIN}-{config_entry.data[CONF_USERNAME]}",
             update_interval=timedelta(
                 seconds=SCAN_INTERVALS[config_entry.data[CONF_REGION]]
             ),
@@ -81,26 +75,26 @@ class BMWDataUpdateCoordinator(DataUpdateCoordinator[None]):
         except MyBMWCaptchaMissingError as err:
             # If a captcha is required (user/password login flow), always trigger the reauth flow
             raise ConfigEntryAuthFailed(
-                translation_domain=BMW_DOMAIN,
+                translation_domain=DOMAIN,
                 translation_key="missing_captcha",
             ) from err
         except MyBMWAuthError as err:
             # Allow one retry interval before raising AuthFailed to avoid flaky API issues
             if self.last_update_success:
                 raise UpdateFailed(
-                    translation_domain=BMW_DOMAIN,
+                    translation_domain=DOMAIN,
                     translation_key="update_failed",
                     translation_placeholders={"exception": str(err)},
                 ) from err
             # Clear refresh token and trigger reauth if previous update failed as well
             self._update_config_entry_refresh_token(None)
             raise ConfigEntryAuthFailed(
-                translation_domain=BMW_DOMAIN,
+                translation_domain=DOMAIN,
                 translation_key="invalid_auth",
             ) from err
         except (MyBMWAPIError, RequestError) as err:
             raise UpdateFailed(
-                translation_domain=BMW_DOMAIN,
+                translation_domain=DOMAIN,
                 translation_key="update_failed",
                 translation_placeholders={"exception": str(err)},
             ) from err

homeassistant/components/bosch_alarm/__init__.py

@@ -6,21 +6,31 @@ from ssl import SSLError
 
 from bosch_alarm_mode2 import Panel
 
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT, Platform
+from homeassistant.const import CONF_HOST, CONF_MAC, CONF_PASSWORD, CONF_PORT, Platform
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
-from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers import config_validation as cv, device_registry as dr
+from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
+from homeassistant.helpers.typing import ConfigType
 
 from .const import CONF_INSTALLER_CODE, CONF_USER_CODE, DOMAIN
+from .services import setup_services
+from .types import BoschAlarmConfigEntry
+
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
 
 PLATFORMS: list[Platform] = [
     Platform.ALARM_CONTROL_PANEL,
+    Platform.BINARY_SENSOR,
     Platform.SENSOR,
     Platform.SWITCH,
 ]
 
-type BoschAlarmConfigEntry = ConfigEntry[Panel]
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up bosch alarm services."""
+    setup_services(hass)
+    return True
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: BoschAlarmConfigEntry) -> bool:
@@ -52,8 +62,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: BoschAlarmConfigEntry) -
 
     device_registry = dr.async_get(hass)
 
+    mac = entry.data.get(CONF_MAC)
+
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
+        connections={(CONNECTION_NETWORK_MAC, mac)} if mac else set(),
         identifiers={(DOMAIN, entry.unique_id or entry.entry_id)},
         name=f"Bosch {panel.model}",
         manufacturer="Bosch Security Systems",

homeassistant/components/bosch_alarm/alarm_control_panel.py

@@ -12,8 +12,8 @@ from homeassistant.components.alarm_control_panel import (
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import BoschAlarmConfigEntry
 from .entity import BoschAlarmAreaEntity
+from .types import BoschAlarmConfigEntry
 
 
 async def async_setup_entry(
@@ -34,6 +34,9 @@ async def async_setup_entry(
     )
 
 
+PARALLEL_UPDATES = 0
+
+
 class AreaAlarmControlPanel(BoschAlarmAreaEntity, AlarmControlPanelEntity):
     """An alarm control panel entity for a bosch alarm panel."""
 
@@ -47,7 +50,7 @@ class AreaAlarmControlPanel(BoschAlarmAreaEntity, AlarmControlPanelEntity):
 
     def __init__(self, panel: Panel, area_id: int, unique_id: str) -> None:
         """Initialise a Bosch Alarm control panel entity."""
-        super().__init__(panel, area_id, unique_id, False, False, True)
+        super().__init__(panel, area_id, unique_id, True, False, True)
         self._attr_unique_id = self._area_unique_id
 
     @property

homeassistant/components/bosch_alarm/binary_sensor.py

@@ -0,0 +1,220 @@
+"""Support for Bosch Alarm Panel binary sensors."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from bosch_alarm_mode2 import Panel
+from bosch_alarm_mode2.const import ALARM_PANEL_FAULTS
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.const import EntityCategory
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import BoschAlarmConfigEntry
+from .entity import BoschAlarmAreaEntity, BoschAlarmEntity, BoschAlarmPointEntity
+
+
+@dataclass(kw_only=True, frozen=True)
+class BoschAlarmFaultEntityDescription(BinarySensorEntityDescription):
+    """Describes Bosch Alarm sensor entity."""
+
+    fault: int
+
+
+FAULT_TYPES = [
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_battery_low",
+        entity_registry_enabled_default=True,
+        device_class=BinarySensorDeviceClass.BATTERY,
+        fault=ALARM_PANEL_FAULTS.BATTERY_LOW,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_battery_mising",
+        translation_key="panel_fault_battery_mising",
+        entity_registry_enabled_default=True,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.BATTERY_MISING,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_ac_fail",
+        translation_key="panel_fault_ac_fail",
+        entity_registry_enabled_default=True,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.AC_FAIL,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_phone_line_failure",
+        translation_key="panel_fault_phone_line_failure",
+        entity_registry_enabled_default=False,
+        device_class=BinarySensorDeviceClass.CONNECTIVITY,
+        fault=ALARM_PANEL_FAULTS.PHONE_LINE_FAILURE,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_parameter_crc_fail_in_pif",
+        translation_key="panel_fault_parameter_crc_fail_in_pif",
+        entity_registry_enabled_default=False,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.PARAMETER_CRC_FAIL_IN_PIF,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_communication_fail_since_rps_hang_up",
+        translation_key="panel_fault_communication_fail_since_rps_hang_up",
+        entity_registry_enabled_default=False,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.COMMUNICATION_FAIL_SINCE_RPS_HANG_UP,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_sdi_fail_since_rps_hang_up",
+        translation_key="panel_fault_sdi_fail_since_rps_hang_up",
+        entity_registry_enabled_default=False,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.SDI_FAIL_SINCE_RPS_HANG_UP,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_user_code_tamper_since_rps_hang_up",
+        translation_key="panel_fault_user_code_tamper_since_rps_hang_up",
+        entity_registry_enabled_default=False,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.USER_CODE_TAMPER_SINCE_RPS_HANG_UP,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_fail_to_call_rps_since_rps_hang_up",
+        translation_key="panel_fault_fail_to_call_rps_since_rps_hang_up",
+        entity_registry_enabled_default=False,
+        fault=ALARM_PANEL_FAULTS.FAIL_TO_CALL_RPS_SINCE_RPS_HANG_UP,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_point_bus_fail_since_rps_hang_up",
+        translation_key="panel_fault_point_bus_fail_since_rps_hang_up",
+        entity_registry_enabled_default=False,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.POINT_BUS_FAIL_SINCE_RPS_HANG_UP,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_log_overflow",
+        translation_key="panel_fault_log_overflow",
+        entity_registry_enabled_default=False,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.LOG_OVERFLOW,
+    ),
+    BoschAlarmFaultEntityDescription(
+        key="panel_fault_log_threshold",
+        translation_key="panel_fault_log_threshold",
+        entity_registry_enabled_default=False,
+        device_class=BinarySensorDeviceClass.PROBLEM,
+        fault=ALARM_PANEL_FAULTS.LOG_THRESHOLD,
+    ),
+]
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BoschAlarmConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up binary sensors for alarm points and the connection status."""
+    panel = config_entry.runtime_data
+
+    entities: list[BinarySensorEntity] = [
+        PointSensor(panel, point_id, config_entry.unique_id or config_entry.entry_id)
+        for point_id in panel.points
+    ]
+
+    entities.extend(
+        PanelFaultsSensor(
+            panel,
+            config_entry.unique_id or config_entry.entry_id,
+            fault_type,
+        )
+        for fault_type in FAULT_TYPES
+    )
+
+    entities.extend(
+        AreaReadyToArmSensor(
+            panel, area_id, config_entry.unique_id or config_entry.entry_id, "away"
+        )
+        for area_id in panel.areas
+    )
+
+    entities.extend(
+        AreaReadyToArmSensor(
+            panel, area_id, config_entry.unique_id or config_entry.entry_id, "home"
+        )
+        for area_id in panel.areas
+    )
+
+    async_add_entities(entities)
+
+
+PARALLEL_UPDATES = 0
+
+
+class PanelFaultsSensor(BoschAlarmEntity, BinarySensorEntity):
+    """A binary sensor entity for each fault type in a bosch alarm panel."""
+
+    _attr_entity_category = EntityCategory.DIAGNOSTIC
+    entity_description: BoschAlarmFaultEntityDescription
+
+    def __init__(
+        self,
+        panel: Panel,
+        unique_id: str,
+        entity_description: BoschAlarmFaultEntityDescription,
+    ) -> None:
+        """Set up a binary sensor entity for each fault type in a bosch alarm panel."""
+        super().__init__(panel, unique_id, True)
+        self.entity_description = entity_description
+        self._fault_type = entity_description.fault
+        self._attr_unique_id = f"{unique_id}_fault_{entity_description.key}"
+
+    @property
+    def is_on(self) -> bool:
+        """Return if this fault has occurred."""
+        return self._fault_type in self.panel.panel_faults_ids
+
+
+class AreaReadyToArmSensor(BoschAlarmAreaEntity, BinarySensorEntity):
+    """A binary sensor entity showing if a panel is ready to arm."""
+
+    _attr_entity_category = EntityCategory.DIAGNOSTIC
+
+    def __init__(
+        self, panel: Panel, area_id: int, unique_id: str, arm_type: str
+    ) -> None:
+        """Set up a binary sensor entity for the arming status in a bosch alarm panel."""
+        super().__init__(panel, area_id, unique_id, False, False, True)
+        self.panel = panel
+        self._arm_type = arm_type
+        self._attr_translation_key = f"area_ready_to_arm_{arm_type}"
+        self._attr_unique_id = f"{self._area_unique_id}_ready_to_arm_{arm_type}"
+
+    @property
+    def is_on(self) -> bool:
+        """Return if this panel is ready to arm."""
+        if self._arm_type == "away":
+            return self._area.all_ready
+        if self._arm_type == "home":
+            return self._area.all_ready or self._area.part_ready
+        return False
+
+
+class PointSensor(BoschAlarmPointEntity, BinarySensorEntity):
+    """A binary sensor entity for a point in a bosch alarm panel."""
+
+    _attr_name = None
+
+    def __init__(self, panel: Panel, point_id: int, unique_id: str) -> None:
+        """Set up a binary sensor entity for a point in a bosch alarm panel."""
+        super().__init__(panel, point_id, unique_id)
+        self._attr_unique_id = self._point_unique_id
+
+    @property
+    def is_on(self) -> bool:
+        """Return if this point sensor is on."""
+        return self._point.is_open()

homeassistant/components/bosch_alarm/config_flow.py

@@ -6,25 +6,30 @@ import asyncio
 from collections.abc import Mapping
 import logging
 import ssl
-from typing import Any
+from typing import Any, Self
 
 from bosch_alarm_mode2 import Panel
 import voluptuous as vol
 
 from homeassistant.config_entries import (
+    SOURCE_DHCP,
     SOURCE_RECONFIGURE,
     SOURCE_USER,
+    ConfigEntryState,
     ConfigFlow,
     ConfigFlowResult,
 )
 from homeassistant.const import (
     CONF_CODE,
     CONF_HOST,
+    CONF_MAC,
     CONF_MODEL,
     CONF_PASSWORD,
     CONF_PORT,
 )
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.device_registry import format_mac
+from homeassistant.helpers.service_info.dhcp import DhcpServiceInfo
 
 from .const import CONF_INSTALLER_CODE, CONF_USER_CODE, DOMAIN
 
@@ -88,6 +93,12 @@ class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
         """Init config flow."""
 
         self._data: dict[str, Any] = {}
+        self.mac: str | None = None
+        self.host: str | None = None
+
+    def is_matching(self, other_flow: Self) -> bool:
+        """Return True if other_flow is matching this flow."""
+        return self.mac == other_flow.mac or self.host == other_flow.host
 
     async def async_step_user(
         self, user_input: dict[str, Any] | None = None
@@ -96,9 +107,12 @@ class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
         errors: dict[str, str] = {}
 
         if user_input is not None:
+            self.host = user_input[CONF_HOST]
+            if self.source == SOURCE_USER:
+                self._async_abort_entries_match({CONF_HOST: user_input[CONF_HOST]})
             try:
                 # Use load_selector = 0 to fetch the panel model without authentication.
-                (model, serial) = await try_connect(user_input, 0)
+                (model, _) = await try_connect(user_input, 0)
             except (
                 OSError,
                 ConnectionRefusedError,
@@ -129,6 +143,70 @@ class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
             errors=errors,
         )
 
+    async def async_step_dhcp(
+        self, discovery_info: DhcpServiceInfo
+    ) -> ConfigFlowResult:
+        """Handle DHCP discovery."""
+        self.mac = format_mac(discovery_info.macaddress)
+        self.host = discovery_info.ip
+        if self.hass.config_entries.flow.async_has_matching_flow(self):
+            return self.async_abort(reason="already_in_progress")
+
+        for entry in self.hass.config_entries.async_entries(DOMAIN):
+            if entry.data.get(CONF_MAC) == self.mac:
+                result = self.hass.config_entries.async_update_entry(
+                    entry,
+                    data={
+                        **entry.data,
+                        CONF_HOST: discovery_info.ip,
+                    },
+                )
+                if result:
+                    self.hass.config_entries.async_schedule_reload(entry.entry_id)
+                return self.async_abort(reason="already_configured")
+            if entry.data[CONF_HOST] == discovery_info.ip:
+                if (
+                    not entry.data.get(CONF_MAC)
+                    and entry.state is ConfigEntryState.LOADED
+                ):
+                    result = self.hass.config_entries.async_update_entry(
+                        entry,
+                        data={
+                            **entry.data,
+                            CONF_MAC: self.mac,
+                        },
+                    )
+                    if result:
+                        self.hass.config_entries.async_schedule_reload(entry.entry_id)
+                return self.async_abort(reason="already_configured")
+        try:
+            # Use load_selector = 0 to fetch the panel model without authentication.
+            (model, _) = await try_connect(
+                {CONF_HOST: discovery_info.ip, CONF_PORT: 7700}, 0
+            )
+        except (
+            OSError,
+            ConnectionRefusedError,
+            ssl.SSLError,
+            asyncio.exceptions.TimeoutError,
+        ):
+            return self.async_abort(reason="cannot_connect")
+        except Exception:
+            _LOGGER.exception("Unexpected exception")
+            return self.async_abort(reason="unknown")
+        self.context["title_placeholders"] = {
+            "model": model,
+            "host": discovery_info.ip,
+        }
+        self._data = {
+            CONF_HOST: discovery_info.ip,
+            CONF_MAC: self.mac,
+            CONF_MODEL: model,
+            CONF_PORT: 7700,
+        }
+
+        return await self.async_step_auth()
+
     async def async_step_reconfigure(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
@@ -172,7 +250,7 @@ class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
             else:
                 if serial_number:
                     await self.async_set_unique_id(str(serial_number))
-                if self.source == SOURCE_USER:
+                if self.source in (SOURCE_USER, SOURCE_DHCP):
                     if serial_number:
                         self._abort_if_unique_id_configured()
                     else:
@@ -184,6 +262,7 @@ class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):
                     )
                 if serial_number:
                     self._abort_if_unique_id_mismatch(reason="device_mismatch")
+
                 return self.async_update_reload_and_abort(
                     self._get_reconfigure_entry(),
                     data=self._data,

homeassistant/components/bosch_alarm/const.py

@@ -1,6 +1,9 @@
 """Constants for the Bosch Alarm integration."""
 
 DOMAIN = "bosch_alarm"
-HISTORY_ATTR = "history"
+ATTR_HISTORY = "history"
 CONF_INSTALLER_CODE = "installer_code"
 CONF_USER_CODE = "user_code"
+ATTR_DATETIME = "datetime"
+SERVICE_SET_DATE_TIME = "set_date_time"
+ATTR_CONFIG_ENTRY_ID = "config_entry_id"

homeassistant/components/bosch_alarm/diagnostics.py

@@ -6,8 +6,8 @@ from homeassistant.components.diagnostics import async_redact_data
 from homeassistant.const import CONF_PASSWORD
 from homeassistant.core import HomeAssistant
 
-from . import BoschAlarmConfigEntry
 from .const import CONF_INSTALLER_CODE, CONF_USER_CODE
+from .types import BoschAlarmConfigEntry
 
 TO_REDACT = [CONF_INSTALLER_CODE, CONF_USER_CODE, CONF_PASSWORD]
 

homeassistant/components/bosch_alarm/entity.py

@@ -17,9 +17,13 @@ class BoschAlarmEntity(Entity):
 
     _attr_has_entity_name = True
 
-    def __init__(self, panel: Panel, unique_id: str) -> None:
+    def __init__(
+        self, panel: Panel, unique_id: str, observe_faults: bool = False
+    ) -> None:
         """Set up a entity for a bosch alarm panel."""
         self.panel = panel
+        self._observe_faults = observe_faults
+        self._attr_should_poll = False
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, unique_id)},
             name=f"Bosch {panel.model}",
@@ -34,10 +38,14 @@ class BoschAlarmEntity(Entity):
     async def async_added_to_hass(self) -> None:
         """Observe state changes."""
         self.panel.connection_status_observer.attach(self.schedule_update_ha_state)
+        if self._observe_faults:
+            self.panel.faults_observer.attach(self.schedule_update_ha_state)
 
     async def async_will_remove_from_hass(self) -> None:
         """Stop observing state changes."""
         self.panel.connection_status_observer.detach(self.schedule_update_ha_state)
+        if self._observe_faults:
+            self.panel.faults_observer.attach(self.schedule_update_ha_state)
 
 
 class BoschAlarmAreaEntity(BoschAlarmEntity):
@@ -88,6 +96,33 @@ class BoschAlarmAreaEntity(BoschAlarmEntity):
             self._area.status_observer.detach(self.schedule_update_ha_state)
 
 
+class BoschAlarmPointEntity(BoschAlarmEntity):
+    """A base entity for point related entities within a bosch alarm panel."""
+
+    def __init__(self, panel: Panel, point_id: int, unique_id: str) -> None:
+        """Set up a area related entity for a bosch alarm panel."""
+        super().__init__(panel, unique_id)
+        self._point_id = point_id
+        self._point_unique_id = f"{unique_id}_point_{point_id}"
+        self._point = panel.points[point_id]
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, self._point_unique_id)},
+            name=self._point.name,
+            manufacturer="Bosch Security Systems",
+            via_device=(DOMAIN, unique_id),
+        )
+
+    async def async_added_to_hass(self) -> None:
+        """Observe state changes."""
+        await super().async_added_to_hass()
+        self._point.status_observer.attach(self.schedule_update_ha_state)
+
+    async def async_will_remove_from_hass(self) -> None:
+        """Stop observing state changes."""
+        await super().async_added_to_hass()
+        self._point.status_observer.detach(self.schedule_update_ha_state)
+
+
 class BoschAlarmDoorEntity(BoschAlarmEntity):
     """A base entity for area related entities within a bosch alarm panel."""