Stop writing to config dir log file on supervised install

The path to the log file in the config directory was wrong, so it was
never deleted. This fixes the path and also asserts file existence.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,14 +1,15 @@
 name: Report an issue with Home Assistant Core
 description: Report an issue with Home Assistant Core.
+type: Bug
 body:
   - type: markdown
     attributes:
       value: |
         This issue form is for reporting bugs only!
 
-        If you have a feature or enhancement request, please [request them here instead][fr].
+        If you have a feature or enhancement request, please use the [feature request][fr] section of our [Community Forum][fr].
 
-        [fr]: https://github.com/orgs/home-assistant/discussions
+        [fr]: https://community.home-assistant.io/c/feature-requests
   - type: textarea
     validations:
       required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -10,8 +10,8 @@ contact_links:
     url: https://www.home-assistant.io/help
     about: We use GitHub for tracking bugs, check our website for resources on getting help.
   - name: Feature Request
-    url: https://github.com/orgs/home-assistant/discussions
-    about: Please use this link to request new features or enhancements to existing features.
+    url: https://community.home-assistant.io/c/feature-requests
+    about: Please use our Community Forum for making feature requests.
   - name: I'm unsure where to go
     url: https://www.home-assistant.io/join-chat
     about: If you are unsure where to go, then joining our chat is recommended; Just ask!

.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@v11
+        uses: dawidd6/action-download-artifact@v10
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
           repo: home-assistant/frontend
@@ -105,10 +105,10 @@ jobs:
 
       - name: Download nightly wheels of intents
         if: needs.init.outputs.channel == 'dev'
-        uses: dawidd6/action-download-artifact@v11
+        uses: dawidd6/action-download-artifact@v10
         with:
           github_token: ${{secrets.GITHUB_TOKEN}}
-          repo: OHF-Voice/intents-package
+          repo: home-assistant/intents-package
           branch: main
           workflow: nightly.yaml
           workflow_conclusion: success

.github/workflows/ci.yaml

@@ -37,7 +37,7 @@ on:
         type: boolean
 
 env:
-  CACHE_VERSION: 3
+  CACHE_VERSION: 2
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
   HA_SHORT_VERSION: "2025.7"

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

@@ -64,19 +64,16 @@ jobs:
             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
+            1. Analyze the text and determine the primary language
             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)
+            4. Consider technical terms, code snippets, and URLs as neutral (they don't indicate non-English)
+            5. Focus on the actual sentences and descriptions written by the user
+            6. Return ONLY a JSON object with two fields:
+               - "is_english": boolean (true if the text 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"
+            7. Be lenient - if the text is mostly English with minor non-English elements, consider it English
+            8. Common programming terms, error messages, and technical jargon should not be considered as non-English
 
             Example response:
             {"is_english": false, "detected_language": "Spanish"}
@@ -125,12 +122,6 @@ jobs:
               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

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.0
+    rev: v0.11.12
     hooks:
       - id: ruff-check
         args:

CODEOWNERS

@@ -57,8 +57,6 @@ 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
@@ -1276,8 +1274,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 @allenporter
-/tests/components/remote_calendar/ @Thomas55555 @allenporter
+/homeassistant/components/remote_calendar/ @Thomas55555
+/tests/components/remote_calendar/ @Thomas55555
 /homeassistant/components/renault/ @epenet
 /tests/components/renault/ @epenet
 /homeassistant/components/renson/ @jimmyd-be

homeassistant/__main__.py

@@ -38,7 +38,8 @@ def validate_python() -> None:
 
 def ensure_config_path(config_dir: str) -> None:
     """Validate the configuration directory."""
-    from . import config as config_util  # noqa: PLC0415
+    # pylint: disable-next=import-outside-toplevel
+    from . import config as config_util
 
     lib_dir = os.path.join(config_dir, "deps")
 
@@ -79,7 +80,8 @@ def ensure_config_path(config_dir: str) -> None:
 
 def get_arguments() -> argparse.Namespace:
     """Get parsed passed in arguments."""
-    from . import config as config_util  # noqa: PLC0415
+    # pylint: disable-next=import-outside-toplevel
+    from . import config as config_util
 
     parser = argparse.ArgumentParser(
         description="Home Assistant: Observe, Control, Automate.",
@@ -175,7 +177,8 @@ def main() -> int:
         validate_os()
 
     if args.script is not None:
-        from . import scripts  # noqa: PLC0415
+        # pylint: disable-next=import-outside-toplevel
+        from . import scripts
 
         return scripts.run(args.script)
 
@@ -185,7 +188,8 @@ def main() -> int:
 
     ensure_config_path(config_dir)
 
-    from . import config, runner  # noqa: PLC0415
+    # pylint: disable-next=import-outside-toplevel
+    from . import config, runner
 
     safe_mode = config.safe_mode_enabled(config_dir)
 

homeassistant/auth/mfa_modules/notify.py

@@ -52,28 +52,28 @@ _LOGGER = logging.getLogger(__name__)
 
 def _generate_secret() -> str:
     """Generate a secret."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     return str(pyotp.random_base32())
 
 
 def _generate_random() -> int:
     """Generate a 32 digit number."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     return int(pyotp.random_base32(length=32, chars=list("1234567890")))
 
 
 def _generate_otp(secret: str, count: int) -> str:
     """Generate one time password."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     return str(pyotp.HOTP(secret).at(count))
 
 
 def _verify_otp(secret: str, otp: str, count: int) -> bool:
     """Verify one time password."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     return bool(pyotp.HOTP(secret).verify(otp, count))
 

homeassistant/auth/mfa_modules/totp.py

@@ -37,7 +37,7 @@ DUMMY_SECRET = "FPPTH34D4E3MI2HG"
 
 def _generate_qr_code(data: str) -> str:
     """Generate a base64 PNG string represent QR Code image of data."""
-    import pyqrcode  # noqa: PLC0415
+    import pyqrcode  # pylint: disable=import-outside-toplevel
 
     qr_code = pyqrcode.create(data)
 
@@ -59,7 +59,7 @@ def _generate_qr_code(data: str) -> str:
 
 def _generate_secret_and_qr_code(username: str) -> tuple[str, str, str]:
     """Generate a secret, url, and QR code."""
-    import pyotp  # noqa: PLC0415
+    import pyotp  # pylint: disable=import-outside-toplevel
 
     ota_secret = pyotp.random_base32()
     url = pyotp.totp.TOTP(ota_secret).provisioning_uri(
@@ -107,7 +107,7 @@ class TotpAuthModule(MultiFactorAuthModule):
 
     def _add_ota_secret(self, user_id: str, secret: str | None = None) -> str:
         """Create a ota_secret for user."""
-        import pyotp  # noqa: PLC0415
+        import pyotp  # pylint: disable=import-outside-toplevel
 
         ota_secret: str = secret or pyotp.random_base32()
 
@@ -163,7 +163,7 @@ class TotpAuthModule(MultiFactorAuthModule):
 
     def _validate_2fa(self, user_id: str, code: str) -> bool:
         """Validate two factor authentication code."""
-        import pyotp  # noqa: PLC0415
+        import pyotp  # pylint: disable=import-outside-toplevel
 
         if (ota_secret := self._users.get(user_id)) is None:  # type: ignore[union-attr]
             # even we cannot find user, we still do verify
@@ -196,7 +196,7 @@ class TotpSetupFlow(SetupFlow[TotpAuthModule]):
         Return self.async_show_form(step_id='init') if user_input is None.
         Return self.async_create_entry(data={'result': result}) if finish.
         """
-        import pyotp  # noqa: PLC0415
+        import pyotp  # pylint: disable=import-outside-toplevel
 
         errors: dict[str, str] = {}
 

homeassistant/bootstrap.py

@@ -394,7 +394,7 @@ async def async_setup_hass(
 
 def open_hass_ui(hass: core.HomeAssistant) -> None:
     """Open the UI."""
-    import webbrowser  # noqa: PLC0415
+    import webbrowser  # pylint: disable=import-outside-toplevel
 
     if hass.config.api is None or "frontend" not in hass.config.components:
         _LOGGER.warning("Cannot launch the UI because frontend not loaded")
@@ -561,7 +561,8 @@ async def async_enable_logging(
 
     if not log_no_color:
         try:
-            from colorlog import ColoredFormatter  # noqa: PLC0415
+            # pylint: disable-next=import-outside-toplevel
+            from colorlog import ColoredFormatter
 
             # basicConfig must be called after importing colorlog in order to
             # ensure that the handlers it sets up wraps the correct streams.
@@ -605,41 +606,46 @@ async def async_enable_logging(
     )
     threading.excepthook = lambda args: logging.getLogger().exception(
         "Uncaught thread exception",
-        exc_info=(  # type: ignore[arg-type]  # noqa: LOG014
+        exc_info=(  # type: ignore[arg-type]
             args.exc_type,
             args.exc_value,
             args.exc_traceback,
         ),
     )
 
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO if verbose else logging.WARNING)
+
     # Log errors to a file if we have write access to file or config dir
     if log_file is None:
-        err_log_path = hass.config.path(ERROR_LOG_FILENAME)
+        if "SUPERVISOR" in os.environ:
+            _LOGGER.info("Running in Supervisor, not logging to file")
+            err_log_path = None
+        else:
+            err_log_path = hass.config.path(ERROR_LOG_FILENAME)
     else:
         err_log_path = os.path.abspath(log_file)
 
-    err_path_exists = os.path.isfile(err_log_path)
-    err_dir = os.path.dirname(err_log_path)
+    if err_log_path:
+        err_path_exists = os.path.isfile(err_log_path)
+        err_dir = os.path.dirname(err_log_path)
 
-    # Check if we can write to the error log if it exists or that
-    # we can create files in the containing directory if not.
-    if (err_path_exists and os.access(err_log_path, os.W_OK)) or (
-        not err_path_exists and os.access(err_dir, os.W_OK)
-    ):
-        err_handler = await hass.async_add_executor_job(
-            _create_log_file, err_log_path, log_rotate_days
-        )
+        # Check if we can write to the error log if it exists or that
+        # we can create files in the containing directory if not.
+        if (err_path_exists and os.access(err_log_path, os.W_OK)) or (
+            not err_path_exists and os.access(err_dir, os.W_OK)
+        ):
+            err_handler = await hass.async_add_executor_job(
+                _create_log_file, err_log_path, log_rotate_days
+            )
 
-        err_handler.setFormatter(logging.Formatter(fmt, datefmt=FORMAT_DATETIME))
+            err_handler.setFormatter(logging.Formatter(fmt, datefmt=FORMAT_DATETIME))
+            logger.addHandler(err_handler)
 
-        logger = logging.getLogger()
-        logger.addHandler(err_handler)
-        logger.setLevel(logging.INFO if verbose else logging.WARNING)
-
-        # Save the log file location for access by other components.
-        hass.data[DATA_LOGGING] = err_log_path
-    else:
-        _LOGGER.error("Unable to set up error log %s (access denied)", err_log_path)
+            # Save the log file location for access by other components.
+            hass.data[DATA_LOGGING] = err_log_path
+        else:
+            _LOGGER.error("Unable to set up error log %s (access denied)", err_log_path)
 
     async_activate_log_queue_handler(hass)
 
@@ -1059,5 +1065,5 @@ async def _async_setup_multi_components(
             _LOGGER.error(
                 "Error setting up integration %s - received exception",
                 domain,
-                exc_info=(type(result), result, result.__traceback__),  # noqa: LOG014
+                exc_info=(type(result), result, result.__traceback__),
             )

homeassistant/components/abode/services.py

@@ -6,7 +6,7 @@ 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.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import dispatcher_send
 
@@ -70,7 +70,6 @@ def _trigger_automation(call: ServiceCall) -> None:
         dispatcher_send(call.hass, signal)
 
 
-@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Home Assistant services."""
 

homeassistant/components/ai_task/__init__.py

@@ -1,125 +0,0 @@
-"""Integration to offer AI tasks to Home Assistant."""
-
-import logging
-
-import voluptuous as vol
-
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import (
-    HassJobType,
-    HomeAssistant,
-    ServiceCall,
-    ServiceResponse,
-    SupportsResponse,
-    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, AITaskEntityFeature
-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",
-    "AITaskEntityFeature",
-    "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)
-    hass.services.async_register(
-        DOMAIN,
-        "generate_text",
-        async_service_generate_text,
-        schema=vol.Schema(
-            {
-                vol.Required("task_name"): cv.string,
-                vol.Optional("entity_id"): cv.entity_id,
-                vol.Required("instructions"): cv.string,
-            }
-        ),
-        supports_response=SupportsResponse.ONLY,
-        job_type=HassJobType.Coroutinefunction,
-    )
-    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)
-
-
-async def async_service_generate_text(call: ServiceCall) -> ServiceResponse:
-    """Run the run task service."""
-    result = await async_generate_text(hass=call.hass, **call.data)
-    return result.as_dict()  # type: ignore[return-value]
-
-
-class AITaskPreferences:
-    """AI Task preferences."""
-
-    KEYS = ("gen_text_entity_id",)
-
-    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
-        for key in self.KEYS:
-            setattr(self, key, data[key])
-
-    @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(self.as_dict, 10)
-
-    @callback
-    def as_dict(self) -> dict[str, str | None]:
-        """Get the current preferences."""
-        return {key: getattr(self, key) for key in self.KEYS}

homeassistant/components/ai_task/const.py

@@ -1,29 +0,0 @@
-"""Constants for the AI Task integration."""
-
-from __future__ import annotations
-
-from enum import IntFlag
-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."
-)
-
-
-class AITaskEntityFeature(IntFlag):
-    """Supported features of the AI task entity."""
-
-    GENERATE_TEXT = 1
-    """Generate text based on instructions."""

homeassistant/components/ai_task/entity.py

@@ -1,103 +0,0 @@
-"""Entity for the AI Task integration."""
-
-from collections.abc import AsyncGenerator
-import contextlib
-from typing import final
-
-from propcache.api import cached_property
-
-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, AITaskEntityFeature
-from .task import GenTextTask, GenTextTaskResult
-
-
-class AITaskEntity(RestoreEntity):
-    """Entity that supports conversations."""
-
-    _attr_should_poll = False
-    _attr_supported_features = AITaskEntityFeature(0)
-    __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
-
-    @cached_property
-    def supported_features(self) -> AITaskEntityFeature:
-        """Flag supported features."""
-        return self._attr_supported_features
-
-    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

@@ -1,54 +0,0 @@
-"""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
-
-
-@callback
-def async_setup(hass: HomeAssistant) -> None:
-    """Set up the HTTP API for the conversation integration."""
-    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/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/icons.json

@@ -1,7 +0,0 @@
-{
-  "services": {
-    "generate_text": {
-      "service": "mdi:file-star-four-points-outline"
-    }
-  }
-}

homeassistant/components/ai_task/manifest.json

@@ -1,9 +0,0 @@
-{
-  "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/services.yaml

@@ -1,19 +0,0 @@
-generate_text:
-  fields:
-    task_name:
-      example: "home summary"
-      required: true
-      selector:
-        text:
-    instructions:
-      example: "Generate a funny notification that garage door was left open"
-      required: true
-      selector:
-        text:
-    entity_id:
-      required: false
-      selector:
-        entity:
-          domain: ai_task
-          supported_features:
-            - ai_task.AITaskEntityFeature.GENERATE_TEXT

homeassistant/components/ai_task/strings.json

@@ -1,22 +0,0 @@
-{
-  "services": {
-    "generate_text": {
-      "name": "Generate text",
-      "description": "Use AI to run a task that generates text.",
-      "fields": {
-        "task_name": {
-          "name": "Task Name",
-          "description": "Name of the task."
-        },
-        "instructions": {
-          "name": "Instructions",
-          "description": "Instructions on what needs to be done."
-        },
-        "entity_id": {
-          "name": "Entity ID",
-          "description": "Entity ID to run the task on. If not provided, the preferred entity will be used."
-        }
-      }
-    }
-  }
-}

homeassistant/components/ai_task/task.py

@@ -1,71 +0,0 @@
-"""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, AITaskEntityFeature
-
-
-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")
-
-    if AITaskEntityFeature.GENERATE_TEXT not in entity.supported_features:
-        raise ValueError(f"AI Task entity {entity_id} does not support generating text")
-
-    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."""
-
-    text: str
-    """Generated text."""
-
-    def as_dict(self) -> dict[str, str]:
-        """Return result as a dict."""
-        return {
-            "conversation_id": self.conversation_id,
-            "text": self.text,
-        }

homeassistant/components/airly/config_flow.py

@@ -39,14 +39,14 @@ class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
             )
             self._abort_if_unique_id_configured()
             try:
-                location_point_valid = await check_location(
+                location_point_valid = await test_location(
                     websession,
                     user_input["api_key"],
                     user_input["latitude"],
                     user_input["longitude"],
                 )
                 if not location_point_valid:
-                    location_nearest_valid = await check_location(
+                    location_nearest_valid = await test_location(
                         websession,
                         user_input["api_key"],
                         user_input["latitude"],
@@ -88,7 +88,7 @@ class AirlyFlowHandler(ConfigFlow, domain=DOMAIN):
         )
 
 
-async def check_location(
+async def test_location(
     client: ClientSession,
     api_key: str,
     latitude: float,

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "bronze",
-  "requirements": ["aioamazondevices==3.1.14"]
+  "requirements": ["aioamazondevices==3.0.6"]
 }

homeassistant/components/alexa_devices/notify.py

@@ -7,7 +7,6 @@ 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
@@ -23,7 +22,6 @@ PARALLEL_UPDATES = 1
 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
 
@@ -33,7 +31,6 @@ NOTIFY: Final = (
         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(
@@ -61,7 +58,6 @@ async def async_setup_entry(
         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])
     )
 
 

homeassistant/components/amcrest/services.py

@@ -5,7 +5,7 @@ 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.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import Unauthorized, UnknownUser
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.helpers.service import async_extract_entity_ids
@@ -15,7 +15,6 @@ 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."""
 

homeassistant/components/anthropic/conversation.py

@@ -366,35 +366,15 @@ class AnthropicConversationEntity(
         options = self.entry.options
 
         try:
-            await chat_log.async_provide_llm_data(
-                user_input.as_llm_context(DOMAIN),
+            await chat_log.async_update_llm_data(
+                DOMAIN,
+                user_input,
                 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 = [
@@ -444,7 +424,7 @@ class AnthropicConversationEntity(
                     [
                         content
                         async for content in chat_log.async_add_delta_content_stream(
-                            self.entity_id,
+                            user_input.agent_id,
                             _transform_stream(chat_log, stream, messages),
                         )
                         if not isinstance(content, conversation.AssistantContent)
@@ -455,6 +435,17 @@ 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/apcupsd/sensor.py

@@ -12,7 +12,6 @@ from homeassistant.components.sensor import (
 )
 from homeassistant.const import (
     PERCENTAGE,
-    EntityCategory,
     UnitOfApparentPower,
     UnitOfElectricCurrent,
     UnitOfElectricPotential,
@@ -36,7 +35,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "alarmdel": SensorEntityDescription(
         key="alarmdel",
         translation_key="alarm_delay",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "ambtemp": SensorEntityDescription(
         key="ambtemp",
@@ -49,18 +47,15 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="apc",
         translation_key="apc_status",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "apcmodel": SensorEntityDescription(
         key="apcmodel",
         translation_key="apc_model",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "badbatts": SensorEntityDescription(
         key="badbatts",
         translation_key="bad_batteries",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "battdate": SensorEntityDescription(
         key="battdate",
@@ -87,7 +82,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="cable",
         translation_key="cable_type",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "cumonbatt": SensorEntityDescription(
         key="cumonbatt",
@@ -100,63 +94,52 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="date",
         translation_key="date",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "dipsw": SensorEntityDescription(
         key="dipsw",
         translation_key="dip_switch_settings",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "dlowbatt": SensorEntityDescription(
         key="dlowbatt",
         translation_key="low_battery_signal",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "driver": SensorEntityDescription(
         key="driver",
         translation_key="driver",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "dshutd": SensorEntityDescription(
         key="dshutd",
         translation_key="shutdown_delay",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "dwake": SensorEntityDescription(
         key="dwake",
         translation_key="wake_delay",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "end apc": SensorEntityDescription(
         key="end apc",
         translation_key="date_and_time",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "extbatts": SensorEntityDescription(
         key="extbatts",
         translation_key="external_batteries",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "firmware": SensorEntityDescription(
         key="firmware",
         translation_key="firmware_version",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "hitrans": SensorEntityDescription(
         key="hitrans",
         translation_key="transfer_high",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "hostname": SensorEntityDescription(
         key="hostname",
         translation_key="hostname",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "humidity": SensorEntityDescription(
         key="humidity",
@@ -180,12 +163,10 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="lastxfer",
         translation_key="last_transfer",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "linefail": SensorEntityDescription(
         key="linefail",
         translation_key="line_failure",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "linefreq": SensorEntityDescription(
         key="linefreq",
@@ -217,18 +198,15 @@ SENSORS: dict[str, SensorEntityDescription] = {
         translation_key="transfer_low",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "mandate": SensorEntityDescription(
         key="mandate",
         translation_key="manufacture_date",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "masterupd": SensorEntityDescription(
         key="masterupd",
         translation_key="master_update",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "maxlinev": SensorEntityDescription(
         key="maxlinev",
@@ -239,13 +217,11 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "maxtime": SensorEntityDescription(
         key="maxtime",
         translation_key="max_time",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "mbattchg": SensorEntityDescription(
         key="mbattchg",
         translation_key="max_battery_charge",
         native_unit_of_measurement=PERCENTAGE,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "minlinev": SensorEntityDescription(
         key="minlinev",
@@ -256,48 +232,41 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "mintimel": SensorEntityDescription(
         key="mintimel",
         translation_key="min_time",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "model": SensorEntityDescription(
         key="model",
         translation_key="model",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nombattv": SensorEntityDescription(
         key="nombattv",
         translation_key="battery_nominal_voltage",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nominv": SensorEntityDescription(
         key="nominv",
         translation_key="nominal_input_voltage",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nomoutv": SensorEntityDescription(
         key="nomoutv",
         translation_key="nominal_output_voltage",
         native_unit_of_measurement=UnitOfElectricPotential.VOLT,
         device_class=SensorDeviceClass.VOLTAGE,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nompower": SensorEntityDescription(
         key="nompower",
         translation_key="nominal_output_power",
         native_unit_of_measurement=UnitOfPower.WATT,
         device_class=SensorDeviceClass.POWER,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "nomapnt": SensorEntityDescription(
         key="nomapnt",
         translation_key="nominal_apparent_power",
         native_unit_of_measurement=UnitOfApparentPower.VOLT_AMPERE,
         device_class=SensorDeviceClass.APPARENT_POWER,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "numxfers": SensorEntityDescription(
         key="numxfers",
@@ -322,25 +291,21 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="reg1",
         translation_key="register_1_fault",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "reg2": SensorEntityDescription(
         key="reg2",
         translation_key="register_2_fault",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "reg3": SensorEntityDescription(
         key="reg3",
         translation_key="register_3_fault",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "retpct": SensorEntityDescription(
         key="retpct",
         translation_key="restore_capacity",
         native_unit_of_measurement=PERCENTAGE,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "selftest": SensorEntityDescription(
         key="selftest",
@@ -350,24 +315,20 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="sense",
         translation_key="sensitivity",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "serialno": SensorEntityDescription(
         key="serialno",
         translation_key="serial_number",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "starttime": SensorEntityDescription(
         key="starttime",
         translation_key="startup_time",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "statflag": SensorEntityDescription(
         key="statflag",
         translation_key="online_status",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "status": SensorEntityDescription(
         key="status",
@@ -376,7 +337,6 @@ SENSORS: dict[str, SensorEntityDescription] = {
     "stesti": SensorEntityDescription(
         key="stesti",
         translation_key="self_test_interval",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "timeleft": SensorEntityDescription(
         key="timeleft",
@@ -400,28 +360,23 @@ SENSORS: dict[str, SensorEntityDescription] = {
         key="upsname",
         translation_key="ups_name",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "version": SensorEntityDescription(
         key="version",
         translation_key="version",
         entity_registry_enabled_default=False,
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xoffbat": SensorEntityDescription(
         key="xoffbat",
         translation_key="transfer_from_battery",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xoffbatt": SensorEntityDescription(
         key="xoffbatt",
         translation_key="transfer_from_battery",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
     "xonbatt": SensorEntityDescription(
         key="xonbatt",
         translation_key="transfer_to_battery",
-        entity_category=EntityCategory.DIAGNOSTIC,
     ),
 }
 

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}"
+        connect = f"ssh {self.username}@{self.host} -o HostKeyAlgorithms=ssh-rsa"
         ssh: pexpect.spawn[str] = pexpect.spawn(connect, encoding="utf-8")
         query = ssh.expect(
             [

homeassistant/components/assist_satellite/__init__.py

@@ -1,23 +1,13 @@
 """Base class for assist satellite entities."""
 
-from dataclasses import asdict
 import logging
 from pathlib import Path
-from typing import Any
 
-from hassil.util import (
-    PUNCTUATION_END,
-    PUNCTUATION_END_WORD,
-    PUNCTUATION_START,
-    PUNCTUATION_START_WORD,
-)
 import voluptuous as vol
 
 from homeassistant.components.http import StaticPathConfig
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_ENTITY_ID
-from homeassistant.core import HomeAssistant, ServiceCall, SupportsResponse
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.entity_component import EntityComponent
 from homeassistant.helpers.typing import ConfigType
@@ -33,7 +23,6 @@ from .const import (
 )
 from .entity import (
     AssistSatelliteAnnouncement,
-    AssistSatelliteAnswer,
     AssistSatelliteConfiguration,
     AssistSatelliteEntity,
     AssistSatelliteEntityDescription,
@@ -45,7 +34,6 @@ from .websocket_api import async_register_websocket_api
 __all__ = [
     "DOMAIN",
     "AssistSatelliteAnnouncement",
-    "AssistSatelliteAnswer",
     "AssistSatelliteConfiguration",
     "AssistSatelliteEntity",
     "AssistSatelliteEntityDescription",
@@ -98,62 +86,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         "async_internal_start_conversation",
         [AssistSatelliteEntityFeature.START_CONVERSATION],
     )
-
-    async def handle_ask_question(call: ServiceCall) -> dict[str, Any]:
-        """Handle a Show View service call."""
-        satellite_entity_id: str = call.data[ATTR_ENTITY_ID]
-        satellite_entity: AssistSatelliteEntity | None = component.get_entity(
-            satellite_entity_id
-        )
-        if satellite_entity is None:
-            raise HomeAssistantError(
-                f"Invalid Assist satellite entity id: {satellite_entity_id}"
-            )
-
-        ask_question_args = {
-            "question": call.data.get("question"),
-            "question_media_id": call.data.get("question_media_id"),
-            "preannounce": call.data.get("preannounce", False),
-            "answers": call.data.get("answers"),
-        }
-
-        if preannounce_media_id := call.data.get("preannounce_media_id"):
-            ask_question_args["preannounce_media_id"] = preannounce_media_id
-
-        answer = await satellite_entity.async_internal_ask_question(**ask_question_args)
-
-        if answer is None:
-            raise HomeAssistantError("No answer from satellite")
-
-        return asdict(answer)
-
-    hass.services.async_register(
-        domain=DOMAIN,
-        service="ask_question",
-        service_func=handle_ask_question,
-        schema=vol.All(
-            {
-                vol.Required(ATTR_ENTITY_ID): cv.entity_domain(DOMAIN),
-                vol.Optional("question"): str,
-                vol.Optional("question_media_id"): str,
-                vol.Optional("preannounce"): bool,
-                vol.Optional("preannounce_media_id"): str,
-                vol.Optional("answers"): [
-                    {
-                        vol.Required("id"): str,
-                        vol.Required("sentences"): vol.All(
-                            cv.ensure_list,
-                            [cv.string],
-                            has_one_non_empty_item,
-                            has_no_punctuation,
-                        ),
-                    }
-                ],
-            },
-            cv.has_at_least_one_key("question", "question_media_id"),
-        ),
-        supports_response=SupportsResponse.ONLY,
-    )
     hass.data[CONNECTION_TEST_DATA] = {}
     async_register_websocket_api(hass)
     hass.http.register_view(ConnectionTestView())
@@ -178,29 +110,3 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
     return await hass.data[DATA_COMPONENT].async_unload_entry(entry)
-
-
-def has_no_punctuation(value: list[str]) -> list[str]:
-    """Validate result does not contain punctuation."""
-    for sentence in value:
-        if (
-            PUNCTUATION_START.search(sentence)
-            or PUNCTUATION_END.search(sentence)
-            or PUNCTUATION_START_WORD.search(sentence)
-            or PUNCTUATION_END_WORD.search(sentence)
-        ):
-            raise vol.Invalid("sentence should not contain punctuation")
-
-    return value
-
-
-def has_one_non_empty_item(value: list[str]) -> list[str]:
-    """Validate result has at least one item."""
-    if len(value) < 1:
-        raise vol.Invalid("at least one sentence is required")
-
-    for sentence in value:
-        if not sentence:
-            raise vol.Invalid("sentences cannot be empty")
-
-    return value

homeassistant/components/assist_satellite/entity.py

@@ -4,16 +4,12 @@ from abc import abstractmethod
 import asyncio
 from collections.abc import AsyncIterable
 import contextlib
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from enum import StrEnum
 import logging
 import time
 from typing import Any, Literal, final
 
-from hassil import Intents, recognize
-from hassil.expression import Expression, ListReference, Sequence
-from hassil.intents import WildcardSlotList
-
 from homeassistant.components import conversation, media_source, stt, tts
 from homeassistant.components.assist_pipeline import (
     OPTION_PREFERRED,
@@ -109,20 +105,6 @@ class AssistSatelliteAnnouncement:
     """Media ID to be played before announcement."""
 
 
-@dataclass
-class AssistSatelliteAnswer:
-    """Answer to a question."""
-
-    id: str | None
-    """Matched answer id or None if no answer was matched."""
-
-    sentence: str
-    """Raw sentence text from user response."""
-
-    slots: dict[str, Any] = field(default_factory=dict)
-    """Matched slots from answer."""
-
-
 class AssistSatelliteEntity(entity.Entity):
     """Entity encapsulating the state and functionality of an Assist satellite."""
 
@@ -140,7 +122,6 @@ class AssistSatelliteEntity(entity.Entity):
     _wake_word_intercept_future: asyncio.Future[str | None] | None = None
     _attr_tts_options: dict[str, Any] | None = None
     _pipeline_task: asyncio.Task | None = None
-    _ask_question_future: asyncio.Future[str | None] | None = None
 
     __assist_satellite_state = AssistSatelliteState.IDLE
 
@@ -328,112 +309,6 @@ class AssistSatelliteEntity(entity.Entity):
         """Start a conversation from the satellite."""
         raise NotImplementedError
 
-    async def async_internal_ask_question(
-        self,
-        question: str | None = None,
-        question_media_id: str | None = None,
-        preannounce: bool = True,
-        preannounce_media_id: str = PREANNOUNCE_URL,
-        answers: list[dict[str, Any]] | None = None,
-    ) -> AssistSatelliteAnswer | None:
-        """Ask a question and get a user's response from the satellite.
-
-        If question_media_id is not provided, question is synthesized to audio
-        with the selected pipeline.
-
-        If question_media_id is provided, it is played directly. It is possible
-        to omit the message and the satellite will not show any text.
-
-        If preannounce is True, a sound is played before the start message or media.
-        If preannounce_media_id is provided, it overrides the default sound.
-
-        Calls async_start_conversation.
-        """
-        await self._cancel_running_pipeline()
-
-        if question is None:
-            question = ""
-
-        announcement = await self._resolve_announcement_media_id(
-            question,
-            question_media_id,
-            preannounce_media_id=preannounce_media_id if preannounce else None,
-        )
-
-        if self._is_announcing:
-            raise SatelliteBusyError
-
-        self._is_announcing = True
-        self._set_state(AssistSatelliteState.RESPONDING)
-        self._ask_question_future = asyncio.Future()
-
-        try:
-            # Wait for announcement to finish
-            await self.async_start_conversation(announcement)
-
-            # Wait for response text
-            response_text = await self._ask_question_future
-            if response_text is None:
-                raise HomeAssistantError("No answer from question")
-
-            if not answers:
-                return AssistSatelliteAnswer(id=None, sentence=response_text)
-
-            return self._question_response_to_answer(response_text, answers)
-        finally:
-            self._is_announcing = False
-            self._set_state(AssistSatelliteState.IDLE)
-            self._ask_question_future = None
-
-    def _question_response_to_answer(
-        self, response_text: str, answers: list[dict[str, Any]]
-    ) -> AssistSatelliteAnswer:
-        """Match text to a pre-defined set of answers."""
-
-        # Build intents and match
-        intents = Intents.from_dict(
-            {
-                "language": self.hass.config.language,
-                "intents": {
-                    "QuestionIntent": {
-                        "data": [
-                            {
-                                "sentences": answer["sentences"],
-                                "metadata": {"answer_id": answer["id"]},
-                            }
-                            for answer in answers
-                        ]
-                    }
-                },
-            }
-        )
-
-        # Assume slot list references are wildcards
-        wildcard_names: set[str] = set()
-        for intent in intents.intents.values():
-            for intent_data in intent.data:
-                for sentence in intent_data.sentences:
-                    _collect_list_references(sentence, wildcard_names)
-
-        for wildcard_name in wildcard_names:
-            intents.slot_lists[wildcard_name] = WildcardSlotList(wildcard_name)
-
-        # Match response text
-        result = recognize(response_text, intents)
-        if result is None:
-            # No match
-            return AssistSatelliteAnswer(id=None, sentence=response_text)
-
-        assert result.intent_metadata
-        return AssistSatelliteAnswer(
-            id=result.intent_metadata["answer_id"],
-            sentence=response_text,
-            slots={
-                entity_name: entity.value
-                for entity_name, entity in result.entities.items()
-            },
-        )
-
     async def async_accept_pipeline_from_satellite(
         self,
         audio_stream: AsyncIterable[bytes],
@@ -476,11 +351,6 @@ class AssistSatelliteEntity(entity.Entity):
             self._internal_on_pipeline_event(PipelineEvent(PipelineEventType.RUN_END))
             return
 
-        if (self._ask_question_future is not None) and (
-            start_stage == PipelineStage.STT
-        ):
-            end_stage = PipelineStage.STT
-
         device_id = self.registry_entry.device_id if self.registry_entry else None
 
         # Refresh context if necessary
@@ -563,16 +433,6 @@ class AssistSatelliteEntity(entity.Entity):
                 self._set_state(AssistSatelliteState.IDLE)
         elif event.type is PipelineEventType.STT_START:
             self._set_state(AssistSatelliteState.LISTENING)
-        elif event.type is PipelineEventType.STT_END:
-            # Intercepting text for ask question
-            if (
-                (self._ask_question_future is not None)
-                and (not self._ask_question_future.done())
-                and event.data
-            ):
-                self._ask_question_future.set_result(
-                    event.data.get("stt_output", {}).get("text")
-                )
         elif event.type is PipelineEventType.INTENT_START:
             self._set_state(AssistSatelliteState.PROCESSING)
         elif event.type is PipelineEventType.TTS_START:
@@ -583,12 +443,6 @@ class AssistSatelliteEntity(entity.Entity):
             if not self._run_has_tts:
                 self._set_state(AssistSatelliteState.IDLE)
 
-            if (self._ask_question_future is not None) and (
-                not self._ask_question_future.done()
-            ):
-                # No text for ask question
-                self._ask_question_future.set_result(None)
-
         self.on_pipeline_event(event)
 
     @callback
@@ -723,15 +577,3 @@ class AssistSatelliteEntity(entity.Entity):
             media_id_source=media_id_source,
             preannounce_media_id=preannounce_media_id,
         )
-
-
-def _collect_list_references(expression: Expression, list_names: set[str]) -> None:
-    """Collect list reference names recursively."""
-    if isinstance(expression, Sequence):
-        seq: Sequence = expression
-        for item in seq.items:
-            _collect_list_references(item, list_names)
-    elif isinstance(expression, ListReference):
-        # {list}
-        list_ref: ListReference = expression
-        list_names.add(list_ref.slot_name)

homeassistant/components/assist_satellite/icons.json

@@ -10,9 +10,6 @@
     },
     "start_conversation": {
       "service": "mdi:forum"
-    },
-    "ask_question": {
-      "service": "mdi:microphone-question"
     }
   }
 }

homeassistant/components/assist_satellite/manifest.json

@@ -5,6 +5,5 @@
   "dependencies": ["assist_pipeline", "http", "stt", "tts"],
   "documentation": "https://www.home-assistant.io/integrations/assist_satellite",
   "integration_type": "entity",
-  "quality_scale": "internal",
-  "requirements": ["hassil==2.2.3"]
+  "quality_scale": "internal"
 }

homeassistant/components/assist_satellite/services.yaml

@@ -54,35 +54,3 @@ start_conversation:
       required: false
       selector:
         text:
-ask_question:
-  fields:
-    entity_id:
-      required: true
-      selector:
-        entity:
-          domain: assist_satellite
-          supported_features:
-            - assist_satellite.AssistSatelliteEntityFeature.START_CONVERSATION
-    question:
-      required: false
-      example: "What kind of music would you like to play?"
-      default: ""
-      selector:
-        text:
-    question_media_id:
-      required: false
-      selector:
-        text:
-    preannounce:
-      required: false
-      default: true
-      selector:
-        boolean:
-    preannounce_media_id:
-      required: false
-      selector:
-        text:
-    answers:
-      required: false
-      selector:
-        object:

homeassistant/components/assist_satellite/strings.json

@@ -59,36 +59,6 @@
           "description": "Custom media ID to play before the start message or media."
         }
       }
-    },
-    "ask_question": {
-      "name": "Ask question",
-      "description": "Asks a question and gets the user's response.",
-      "fields": {
-        "entity_id": {
-          "name": "Entity",
-          "description": "Assist satellite entity to ask the question on."
-        },
-        "question": {
-          "name": "Question",
-          "description": "The question to ask."
-        },
-        "question_media_id": {
-          "name": "Question media ID",
-          "description": "The media ID of the question to use instead of text-to-speech."
-        },
-        "preannounce": {
-          "name": "Preannounce",
-          "description": "Play a sound before the start message or media."
-        },
-        "preannounce_media_id": {
-          "name": "Preannounce media ID",
-          "description": "Custom media ID to play before the start message or media."
-        },
-        "answers": {
-          "name": "Answers",
-          "description": "Possible answers to the question."
-        }
-      }
     }
   }
 }

homeassistant/components/automation/helpers.py

@@ -12,7 +12,7 @@ DATA_BLUEPRINTS = "automation_blueprints"
 
 def _blueprint_in_use(hass: HomeAssistant, blueprint_path: str) -> bool:
     """Return True if any automation references the blueprint."""
-    from . import automations_with_blueprint  # noqa: PLC0415
+    from . import automations_with_blueprint  # pylint: disable=import-outside-toplevel
 
     return len(automations_with_blueprint(hass, blueprint_path)) > 0
 
@@ -28,7 +28,8 @@ async def _reload_blueprint_automations(
 @callback
 def async_get_blueprints(hass: HomeAssistant) -> blueprint.DomainBlueprints:
     """Get automation blueprints."""
-    from .config import AUTOMATION_BLUEPRINT_SCHEMA  # noqa: PLC0415
+    # pylint: disable-next=import-outside-toplevel
+    from .config import AUTOMATION_BLUEPRINT_SCHEMA
 
     return blueprint.DomainBlueprints(
         hass,

homeassistant/components/backup/__init__.py

@@ -94,10 +94,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     if not with_hassio:
         reader_writer = CoreBackupReaderWriter(hass)
     else:
-        # pylint: disable-next=hass-component-root-import
-        from homeassistant.components.hassio.backup import (  # noqa: PLC0415
-            SupervisorBackupReaderWriter,
-        )
+        # pylint: disable-next=import-outside-toplevel, hass-component-root-import
+        from homeassistant.components.hassio.backup import SupervisorBackupReaderWriter
 
         reader_writer = SupervisorBackupReaderWriter(hass)
 

homeassistant/components/bthome/manifest.json

@@ -20,5 +20,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/bthome",
   "iot_class": "local_push",
-  "requirements": ["bthome-ble==3.13.1"]
+  "requirements": ["bthome-ble==3.12.4"]
 }

homeassistant/components/camera/__init__.py

@@ -240,10 +240,6 @@ async def _async_get_stream_image(
     height: int | None = None,
     wait_for_next_keyframe: bool = False,
 ) -> bytes | None:
-    if (provider := camera._webrtc_provider) and (  # noqa: SLF001
-        image := await provider.async_get_image(camera, width=width, height=height)
-    ) is not None:
-        return image
     if not camera.stream and CameraEntityFeature.STREAM in camera.supported_features:
         camera.stream = await camera.async_create_stream()
     if camera.stream:

homeassistant/components/camera/webrtc.py

@@ -156,15 +156,6 @@ class CameraWebRTCProvider(ABC):
         """Close the session."""
         return  ## This is an optional method so we need a default here.
 
-    async def async_get_image(
-        self,
-        camera: Camera,
-        width: int | None = None,
-        height: int | None = None,
-    ) -> bytes | None:
-        """Get an image from the camera."""
-        return None
-
 
 @callback
 def async_register_webrtc_provider(

homeassistant/components/climate/__init__.py

@@ -105,6 +105,11 @@ DEFAULT_MAX_HUMIDITY = 99
 
 CONVERTIBLE_ATTRIBUTE = [ATTR_TEMPERATURE, ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH]
 
+# Can be removed in 2025.1 after deprecation period of the new feature flags
+CHECK_TURN_ON_OFF_FEATURE_FLAG = (
+    ClimateEntityFeature.TURN_ON | ClimateEntityFeature.TURN_OFF
+)
+
 SET_TEMPERATURE_SCHEMA = vol.All(
     cv.has_at_least_one_key(
         ATTR_TEMPERATURE, ATTR_TARGET_TEMP_HIGH, ATTR_TARGET_TEMP_LOW

homeassistant/components/cloud/manifest.json

@@ -13,6 +13,6 @@
   "integration_type": "system",
   "iot_class": "cloud_push",
   "loggers": ["acme", "hass_nabucasa", "snitun"],
-  "requirements": ["hass-nabucasa==0.103.0"],
+  "requirements": ["hass-nabucasa==0.101.0"],
   "single_config_entry": true
 }

homeassistant/components/control4/__init__.py

@@ -54,10 +54,10 @@ class Control4RuntimeData:
 type Control4ConfigEntry = ConfigEntry[Control4RuntimeData]
 
 
-async def call_c4_api_retry(func, *func_args):  # noqa: RET503
+async def call_c4_api_retry(func, *func_args):
     """Call C4 API function and retry on failure."""
     # Ruff doesn't understand this loop - the exception is always raised after the retries
-    for i in range(API_RETRY_TIMES):
+    for i in range(API_RETRY_TIMES):  # noqa: RET503
         try:
             return await func(*func_args)
         except client_exceptions.ClientError as exception:

homeassistant/components/conversation/__init__.py

@@ -271,7 +271,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     )
 
     # Temporary migration. We can remove this in 2024.10
-    from homeassistant.components.assist_pipeline import (  # noqa: PLC0415
+    from homeassistant.components.assist_pipeline import (  # pylint: disable=import-outside-toplevel
         async_migrate_engine,
     )
 

homeassistant/components/conversation/chat_log.py

@@ -14,11 +14,12 @@ import voluptuous as vol
 
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, TemplateError
-from homeassistant.helpers import chat_session, frame, intent, llm, template
+from homeassistant.helpers import chat_session, intent, llm, template
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.json import JsonObjectType
 
 from . import trace
+from .const import DOMAIN
 from .models import ConversationInput, ConversationResult
 
 DATA_CHAT_LOGS: HassKey[dict[str, ChatLog]] = HassKey("conversation_chat_logs")
@@ -358,7 +359,7 @@ class ChatLog:
         self,
         llm_context: llm.LLMContext,
         prompt: str,
-        language: str | None,
+        language: str,
         user_name: str | None = None,
     ) -> str:
         try:
@@ -372,7 +373,7 @@ class ChatLog:
             )
         except TemplateError as err:
             LOGGER.error("Error rendering prompt: %s", err)
-            intent_response = intent.IntentResponse(language=language or "")
+            intent_response = intent.IntentResponse(language=language)
             intent_response.async_set_error(
                 intent.IntentResponseErrorCode.UNKNOWN,
                 "Sorry, I had a problem with my template",
@@ -391,25 +392,15 @@ class ChatLog:
         user_llm_prompt: str | None = None,
     ) -> None:
         """Set the LLM system prompt."""
-        frame.report_usage(
-            "ChatLog.async_update_llm_data",
-            breaks_in_ha_version="2026.1",
-        )
-        return await self.async_provide_llm_data(
-            llm_context=user_input.as_llm_context(conversing_domain),
-            user_llm_hass_api=user_llm_hass_api,
-            user_llm_prompt=user_llm_prompt,
-            user_extra_system_prompt=user_input.extra_system_prompt,
+        llm_context = llm.LLMContext(
+            platform=conversing_domain,
+            context=user_input.context,
+            user_prompt=user_input.text,
+            language=user_input.language,
+            assistant=DOMAIN,
+            device_id=user_input.device_id,
         )
 
-    async def async_provide_llm_data(
-        self,
-        llm_context: llm.LLMContext,
-        user_llm_hass_api: str | list[str] | None = None,
-        user_llm_prompt: str | None = None,
-        user_extra_system_prompt: str | None = None,
-    ) -> None:
-        """Set the LLM system prompt."""
         llm_api: llm.APIInstance | None = None
 
         if user_llm_hass_api:
@@ -423,12 +414,10 @@ class ChatLog:
                 LOGGER.error(
                     "Error getting LLM API %s for %s: %s",
                     user_llm_hass_api,
-                    llm_context.platform,
+                    conversing_domain,
                     err,
                 )
-                intent_response = intent.IntentResponse(
-                    language=llm_context.language or ""
-                )
+                intent_response = intent.IntentResponse(language=user_input.language)
                 intent_response.async_set_error(
                     intent.IntentResponseErrorCode.UNKNOWN,
                     "Error preparing LLM API",
@@ -442,10 +431,10 @@ class ChatLog:
         user_name: str | None = None
 
         if (
-            llm_context.context
-            and llm_context.context.user_id
+            user_input.context
+            and user_input.context.user_id
             and (
-                user := await self.hass.auth.async_get_user(llm_context.context.user_id)
+                user := await self.hass.auth.async_get_user(user_input.context.user_id)
             )
         ):
             user_name = user.name
@@ -455,7 +444,7 @@ class ChatLog:
             await self._async_expand_prompt_template(
                 llm_context,
                 (user_llm_prompt or llm.DEFAULT_INSTRUCTIONS_PROMPT),
-                llm_context.language,
+                user_input.language,
                 user_name,
             )
         )
@@ -467,14 +456,14 @@ class ChatLog:
             await self._async_expand_prompt_template(
                 llm_context,
                 llm.BASE_PROMPT,
-                llm_context.language,
+                user_input.language,
                 user_name,
             )
         )
 
         if extra_system_prompt := (
             # Take new system prompt if one was given
-            user_extra_system_prompt or self.extra_system_prompt
+            user_input.extra_system_prompt or self.extra_system_prompt
         ):
             prompt_parts.append(extra_system_prompt)
 

homeassistant/components/conversation/models.py

@@ -7,9 +7,7 @@ from dataclasses import dataclass
 from typing import Any, Literal
 
 from homeassistant.core import Context
-from homeassistant.helpers import intent, llm
-
-from .const import DOMAIN
+from homeassistant.helpers import intent
 
 
 @dataclass(frozen=True)
@@ -58,16 +56,6 @@ class ConversationInput:
             "extra_system_prompt": self.extra_system_prompt,
         }
 
-    def as_llm_context(self, conversing_domain: str) -> llm.LLMContext:
-        """Return input as an LLM context."""
-        return llm.LLMContext(
-            platform=conversing_domain,
-            context=self.context,
-            language=self.language,
-            assistant=DOMAIN,
-            device_id=self.device_id,
-        )
-
 
 @dataclass(slots=True)
 class ConversationResult:

homeassistant/components/cover/__init__.py

@@ -300,6 +300,10 @@ class CoverEntity(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
     def supported_features(self) -> CoverEntityFeature:
         """Flag supported features."""
         if (features := self._attr_supported_features) is not None:
+            if type(features) is int:
+                new_features = CoverEntityFeature(features)
+                self._report_deprecated_supported_features_values(new_features)
+                return new_features
             return features
 
         supported_features = (

homeassistant/components/devolo_home_control/__init__.py

@@ -18,7 +18,7 @@ from homeassistant.core import Event, HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 from homeassistant.helpers.device_registry import DeviceEntry
 
-from .const import DOMAIN, GATEWAY_SERIAL_PATTERN, PLATFORMS
+from .const import GATEWAY_SERIAL_PATTERN, PLATFORMS
 
 type DevoloHomeControlConfigEntry = ConfigEntry[list[HomeControl]]
 
@@ -32,16 +32,10 @@ async def async_setup_entry(
     credentials_valid = await hass.async_add_executor_job(mydevolo.credentials_valid)
 
     if not credentials_valid:
-        raise ConfigEntryAuthFailed(
-            translation_domain=DOMAIN,
-            translation_key="invalid_auth",
-        )
+        raise ConfigEntryAuthFailed
 
     if await hass.async_add_executor_job(mydevolo.maintenance):
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="maintenance",
-        )
+        raise ConfigEntryNotReady
 
     gateway_ids = await hass.async_add_executor_job(mydevolo.get_gateway_ids)
 
@@ -75,11 +69,7 @@ async def async_setup_entry(
                 )
             )
     except GatewayOfflineError as err:
-        raise ConfigEntryNotReady(
-            translation_domain=DOMAIN,
-            translation_key="connection_failed",
-            translation_placeholders={"gateway_id": gateway_id},
-        ) from err
+        raise ConfigEntryNotReady from err
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -101,9 +91,7 @@ async def async_unload_entry(
 
 
 async def async_remove_config_entry_device(
-    hass: HomeAssistant,
-    config_entry: DevoloHomeControlConfigEntry,
-    device_entry: DeviceEntry,
+    hass: HomeAssistant, config_entry: ConfigEntry, device_entry: DeviceEntry
 ) -> bool:
     """Remove a config entry from a device."""
     return True

homeassistant/components/devolo_home_control/strings.json

@@ -45,16 +45,5 @@
         "name": "Brightness"
       }
     }
-  },
-  "exceptions": {
-    "connection_failed": {
-      "message": "Failed to connect to devolo Home Control central unit {gateway_id}."
-    },
-    "invalid_auth": {
-      "message": "Authentication failed. Please re-authenticaticate with your mydevolo account."
-    },
-    "maintenance": {
-      "message": "devolo Home Control is currently in maintenance mode."
-    }
   }
 }

homeassistant/components/devolo_home_network/device_tracker.py

@@ -87,7 +87,6 @@ class DevoloScannerEntity(  # pylint: disable=hass-enforce-class-module
 ):
     """Representation of a devolo device tracker."""
 
-    _attr_has_entity_name = True
     _attr_translation_key = "device_tracker"
 
     def __init__(
@@ -100,7 +99,6 @@ class DevoloScannerEntity(  # pylint: disable=hass-enforce-class-module
         super().__init__(coordinator)
         self._device = device
         self._attr_mac_address = mac
-        self._attr_name = mac
 
     @property
     def extra_state_attributes(self) -> dict[str, str]:

homeassistant/components/discord/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "service",
   "iot_class": "cloud_push",
   "loggers": ["discord"],
-  "requirements": ["nextcord==3.1.0"]
+  "requirements": ["nextcord==2.6.0"]
 }

homeassistant/components/dnsip/manifest.json

@@ -5,5 +5,5 @@
   "config_flow": true,
   "documentation": "https://www.home-assistant.io/integrations/dnsip",
   "iot_class": "cloud_polling",
-  "requirements": ["aiodns==3.5.0"]
+  "requirements": ["aiodns==3.4.0"]
 }

homeassistant/components/downloader/services.py

@@ -10,7 +10,7 @@ import threading
 import requests
 import voluptuous as vol
 
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.service import async_register_admin_service
 from homeassistant.util import raise_if_invalid_filename, raise_if_invalid_path
@@ -108,7 +108,8 @@ def download_file(service: ServiceCall) -> None:
                 _LOGGER.debug("%s -> %s", url, final_path)
 
                 with open(final_path, "wb") as fil:
-                    fil.writelines(req.iter_content(1024))
+                    for chunk in req.iter_content(1024):
+                        fil.write(chunk)
 
                 _LOGGER.debug("Downloading of %s done", url)
                 service.hass.bus.fire(
@@ -140,7 +141,6 @@ def download_file(service: ServiceCall) -> None:
     threading.Thread(target=do_download).start()
 
 
-@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Register the services for the downloader component."""
     async_register_admin_service(

homeassistant/components/ecovacs/binary_sensor.py

@@ -2,9 +2,9 @@
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import Generic
 
 from deebot_client.capabilities import CapabilityEvent
-from deebot_client.events.base import Event
 from deebot_client.events.water_info import MopAttachedEvent
 
 from homeassistant.components.binary_sensor import (
@@ -16,14 +16,15 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import EcovacsConfigEntry
-from .entity import EcovacsCapabilityEntityDescription, EcovacsDescriptionEntity
+from .entity import EcovacsCapabilityEntityDescription, EcovacsDescriptionEntity, EventT
 from .util import get_supported_entities
 
 
 @dataclass(kw_only=True, frozen=True)
-class EcovacsBinarySensorEntityDescription[EventT: Event](
+class EcovacsBinarySensorEntityDescription(
     BinarySensorEntityDescription,
     EcovacsCapabilityEntityDescription,
+    Generic[EventT],
 ):
     """Class describing Deebot binary sensor entity."""
 
@@ -54,7 +55,7 @@ async def async_setup_entry(
     )
 
 
-class EcovacsBinarySensor[EventT: Event](
+class EcovacsBinarySensor(
     EcovacsDescriptionEntity[CapabilityEvent[EventT]],
     BinarySensorEntity,
 ):

homeassistant/components/ecovacs/entity.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable, Coroutine
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Generic, TypeVar
 
 from deebot_client.capabilities import Capabilities
 from deebot_client.device import Device
@@ -18,8 +18,11 @@ from homeassistant.helpers.entity import Entity, EntityDescription
 
 from .const import DOMAIN
 
+CapabilityEntity = TypeVar("CapabilityEntity")
+EventT = TypeVar("EventT", bound=Event)
 
-class EcovacsEntity[CapabilityEntityT](Entity):
+
+class EcovacsEntity(Entity, Generic[CapabilityEntity]):
     """Ecovacs entity."""
 
     _attr_should_poll = False
@@ -29,7 +32,7 @@ class EcovacsEntity[CapabilityEntityT](Entity):
     def __init__(
         self,
         device: Device,
-        capability: CapabilityEntityT,
+        capability: CapabilityEntity,
         **kwargs: Any,
     ) -> None:
         """Initialize entity."""
@@ -77,7 +80,7 @@ class EcovacsEntity[CapabilityEntityT](Entity):
 
             self._subscribe(AvailabilityEvent, on_available)
 
-    def _subscribe[EventT: Event](
+    def _subscribe(
         self,
         event_type: type[EventT],
         callback: Callable[[EventT], Coroutine[Any, Any, None]],
@@ -95,13 +98,13 @@ class EcovacsEntity[CapabilityEntityT](Entity):
             self._device.events.request_refresh(event_type)
 
 
-class EcovacsDescriptionEntity[CapabilityEntityT](EcovacsEntity[CapabilityEntityT]):
+class EcovacsDescriptionEntity(EcovacsEntity[CapabilityEntity]):
     """Ecovacs entity."""
 
     def __init__(
         self,
         device: Device,
-        capability: CapabilityEntityT,
+        capability: CapabilityEntity,
         entity_description: EntityDescription,
         **kwargs: Any,
     ) -> None:
@@ -111,12 +114,13 @@ class EcovacsDescriptionEntity[CapabilityEntityT](EcovacsEntity[CapabilityEntity
 
 
 @dataclass(kw_only=True, frozen=True)
-class EcovacsCapabilityEntityDescription[CapabilityEntityT](
+class EcovacsCapabilityEntityDescription(
     EntityDescription,
+    Generic[CapabilityEntity],
 ):
     """Ecovacs entity description."""
 
-    capability_fn: Callable[[Capabilities], CapabilityEntityT | None]
+    capability_fn: Callable[[Capabilities], CapabilityEntity | None]
 
 
 class EcovacsLegacyEntity(Entity):

homeassistant/components/ecovacs/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/ecovacs",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.11", "deebot-client==13.4.0"]
+  "requirements": ["py-sucks==0.9.11", "deebot-client==13.3.0"]
 }

homeassistant/components/ecovacs/number.py

@@ -4,10 +4,10 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import Generic
 
 from deebot_client.capabilities import CapabilitySet
 from deebot_client.events import CleanCountEvent, CutDirectionEvent, VolumeEvent
-from deebot_client.events.base import Event
 
 from homeassistant.components.number import (
     NumberEntity,
@@ -23,14 +23,16 @@ from .entity import (
     EcovacsCapabilityEntityDescription,
     EcovacsDescriptionEntity,
     EcovacsEntity,
+    EventT,
 )
 from .util import get_supported_entities
 
 
 @dataclass(kw_only=True, frozen=True)
-class EcovacsNumberEntityDescription[EventT: Event](
+class EcovacsNumberEntityDescription(
     NumberEntityDescription,
     EcovacsCapabilityEntityDescription,
+    Generic[EventT],
 ):
     """Ecovacs number entity description."""
 
@@ -92,7 +94,7 @@ async def async_setup_entry(
         async_add_entities(entities)
 
 
-class EcovacsNumberEntity[EventT: Event](
+class EcovacsNumberEntity(
     EcovacsDescriptionEntity[CapabilitySet[EventT, [int]]],
     NumberEntity,
 ):

homeassistant/components/ecovacs/select.py

@@ -2,12 +2,11 @@
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Generic
 
 from deebot_client.capabilities import CapabilitySetTypes
 from deebot_client.device import Device
 from deebot_client.events import WorkModeEvent
-from deebot_client.events.base import Event
 from deebot_client.events.water_info import WaterAmountEvent
 
 from homeassistant.components.select import SelectEntity, SelectEntityDescription
@@ -16,14 +15,15 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
 from . import EcovacsConfigEntry
-from .entity import EcovacsCapabilityEntityDescription, EcovacsDescriptionEntity
+from .entity import EcovacsCapabilityEntityDescription, EcovacsDescriptionEntity, EventT
 from .util import get_name_key, get_supported_entities
 
 
 @dataclass(kw_only=True, frozen=True)
-class EcovacsSelectEntityDescription[EventT: Event](
+class EcovacsSelectEntityDescription(
     SelectEntityDescription,
     EcovacsCapabilityEntityDescription,
+    Generic[EventT],
 ):
     """Ecovacs select entity description."""
 
@@ -66,7 +66,7 @@ async def async_setup_entry(
         async_add_entities(entities)
 
 
-class EcovacsSelectEntity[EventT: Event](
+class EcovacsSelectEntity(
     EcovacsDescriptionEntity[CapabilitySetTypes[EventT, [str], str]],
     SelectEntity,
 ):

homeassistant/components/ecovacs/sensor.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, Generic
 
 from deebot_client.capabilities import CapabilityEvent, CapabilityLifeSpan, DeviceType
 from deebot_client.device import Device
@@ -46,14 +46,16 @@ from .entity import (
     EcovacsDescriptionEntity,
     EcovacsEntity,
     EcovacsLegacyEntity,
+    EventT,
 )
 from .util import get_name_key, get_options, get_supported_entities
 
 
 @dataclass(kw_only=True, frozen=True)
-class EcovacsSensorEntityDescription[EventT: Event](
+class EcovacsSensorEntityDescription(
     EcovacsCapabilityEntityDescription,
     SensorEntityDescription,
+    Generic[EventT],
 ):
     """Ecovacs sensor entity description."""
 

homeassistant/components/edl21/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "local_push",
   "loggers": ["sml"],
-  "requirements": ["pysml==0.1.5"]
+  "requirements": ["pysml==0.0.12"]
 }

homeassistant/components/eheimdigital/number.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Any, override
+from typing import Generic, TypeVar, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
@@ -30,16 +30,16 @@ from .entity import EheimDigitalEntity, exception_handler
 
 PARALLEL_UPDATES = 0
 
+_DeviceT_co = TypeVar("_DeviceT_co", bound=EheimDigitalDevice, covariant=True)
+
 
 @dataclass(frozen=True, kw_only=True)
-class EheimDigitalNumberDescription[_DeviceT: EheimDigitalDevice](
-    NumberEntityDescription
-):
+class EheimDigitalNumberDescription(NumberEntityDescription, Generic[_DeviceT_co]):
     """Class describing EHEIM Digital sensor entities."""
 
-    value_fn: Callable[[_DeviceT], float | None]
-    set_value_fn: Callable[[_DeviceT, float], Awaitable[None]]
-    uom_fn: Callable[[_DeviceT], str] | None = None
+    value_fn: Callable[[_DeviceT_co], float | None]
+    set_value_fn: Callable[[_DeviceT_co, float], Awaitable[None]]
+    uom_fn: Callable[[_DeviceT_co], str] | None = None
 
 
 CLASSICVARIO_DESCRIPTIONS: tuple[
@@ -136,7 +136,7 @@ async def async_setup_entry(
         device_address: dict[str, EheimDigitalDevice],
     ) -> None:
         """Set up the number entities for one or multiple devices."""
-        entities: list[EheimDigitalNumber[Any]] = []
+        entities: list[EheimDigitalNumber[EheimDigitalDevice]] = []
         for device in device_address.values():
             if isinstance(device, EheimDigitalClassicVario):
                 entities.extend(
@@ -163,18 +163,18 @@ async def async_setup_entry(
     async_setup_device_entities(coordinator.hub.devices)
 
 
-class EheimDigitalNumber[_DeviceT: EheimDigitalDevice](
-    EheimDigitalEntity[_DeviceT], NumberEntity
+class EheimDigitalNumber(
+    EheimDigitalEntity[_DeviceT_co], NumberEntity, Generic[_DeviceT_co]
 ):
     """Represent a EHEIM Digital number entity."""
 
-    entity_description: EheimDigitalNumberDescription[_DeviceT]
+    entity_description: EheimDigitalNumberDescription[_DeviceT_co]
 
     def __init__(
         self,
         coordinator: EheimDigitalUpdateCoordinator,
-        device: _DeviceT,
-        description: EheimDigitalNumberDescription[_DeviceT],
+        device: _DeviceT_co,
+        description: EheimDigitalNumberDescription[_DeviceT_co],
     ) -> None:
         """Initialize an EHEIM Digital number entity."""
         super().__init__(coordinator, device)

homeassistant/components/eheimdigital/select.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from typing import Any, override
+from typing import Generic, TypeVar, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
@@ -17,15 +17,15 @@ from .entity import EheimDigitalEntity, exception_handler
 
 PARALLEL_UPDATES = 0
 
+_DeviceT_co = TypeVar("_DeviceT_co", bound=EheimDigitalDevice, covariant=True)
+
 
 @dataclass(frozen=True, kw_only=True)
-class EheimDigitalSelectDescription[_DeviceT: EheimDigitalDevice](
-    SelectEntityDescription
-):
+class EheimDigitalSelectDescription(SelectEntityDescription, Generic[_DeviceT_co]):
     """Class describing EHEIM Digital select entities."""
 
-    value_fn: Callable[[_DeviceT], str | None]
-    set_value_fn: Callable[[_DeviceT, str], Awaitable[None]]
+    value_fn: Callable[[_DeviceT_co], str | None]
+    set_value_fn: Callable[[_DeviceT_co, str], Awaitable[None]]
 
 
 CLASSICVARIO_DESCRIPTIONS: tuple[
@@ -59,7 +59,7 @@ async def async_setup_entry(
         device_address: dict[str, EheimDigitalDevice],
     ) -> None:
         """Set up the number entities for one or multiple devices."""
-        entities: list[EheimDigitalSelect[Any]] = []
+        entities: list[EheimDigitalSelect[EheimDigitalDevice]] = []
         for device in device_address.values():
             if isinstance(device, EheimDigitalClassicVario):
                 entities.extend(
@@ -75,18 +75,18 @@ async def async_setup_entry(
     async_setup_device_entities(coordinator.hub.devices)
 
 
-class EheimDigitalSelect[_DeviceT: EheimDigitalDevice](
-    EheimDigitalEntity[_DeviceT], SelectEntity
+class EheimDigitalSelect(
+    EheimDigitalEntity[_DeviceT_co], SelectEntity, Generic[_DeviceT_co]
 ):
     """Represent an EHEIM Digital select entity."""
 
-    entity_description: EheimDigitalSelectDescription[_DeviceT]
+    entity_description: EheimDigitalSelectDescription[_DeviceT_co]
 
     def __init__(
         self,
         coordinator: EheimDigitalUpdateCoordinator,
-        device: _DeviceT,
-        description: EheimDigitalSelectDescription[_DeviceT],
+        device: _DeviceT_co,
+        description: EheimDigitalSelectDescription[_DeviceT_co],
     ) -> None:
         """Initialize an EHEIM Digital select entity."""
         super().__init__(coordinator, device)

homeassistant/components/eheimdigital/sensor.py

@@ -2,7 +2,7 @@
 
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Any, override
+from typing import Generic, TypeVar, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
@@ -20,14 +20,14 @@ from .entity import EheimDigitalEntity
 # Coordinator is used to centralize the data updates
 PARALLEL_UPDATES = 0
 
+_DeviceT_co = TypeVar("_DeviceT_co", bound=EheimDigitalDevice, covariant=True)
+
 
 @dataclass(frozen=True, kw_only=True)
-class EheimDigitalSensorDescription[_DeviceT: EheimDigitalDevice](
-    SensorEntityDescription
-):
+class EheimDigitalSensorDescription(SensorEntityDescription, Generic[_DeviceT_co]):
     """Class describing EHEIM Digital sensor entities."""
 
-    value_fn: Callable[[_DeviceT], float | str | None]
+    value_fn: Callable[[_DeviceT_co], float | str | None]
 
 
 CLASSICVARIO_DESCRIPTIONS: tuple[
@@ -75,7 +75,7 @@ async def async_setup_entry(
         device_address: dict[str, EheimDigitalDevice],
     ) -> None:
         """Set up the light entities for one or multiple devices."""
-        entities: list[EheimDigitalSensor[Any]] = []
+        entities: list[EheimDigitalSensor[EheimDigitalDevice]] = []
         for device in device_address.values():
             if isinstance(device, EheimDigitalClassicVario):
                 entities += [
@@ -91,18 +91,18 @@ async def async_setup_entry(
     async_setup_device_entities(coordinator.hub.devices)
 
 
-class EheimDigitalSensor[_DeviceT: EheimDigitalDevice](
-    EheimDigitalEntity[_DeviceT], SensorEntity
+class EheimDigitalSensor(
+    EheimDigitalEntity[_DeviceT_co], SensorEntity, Generic[_DeviceT_co]
 ):
     """Represent a EHEIM Digital sensor entity."""
 
-    entity_description: EheimDigitalSensorDescription[_DeviceT]
+    entity_description: EheimDigitalSensorDescription[_DeviceT_co]
 
     def __init__(
         self,
         coordinator: EheimDigitalUpdateCoordinator,
-        device: _DeviceT,
-        description: EheimDigitalSensorDescription[_DeviceT],
+        device: _DeviceT_co,
+        description: EheimDigitalSensorDescription[_DeviceT_co],
     ) -> None:
         """Initialize an EHEIM Digital number entity."""
         super().__init__(coordinator, device)

homeassistant/components/eheimdigital/time.py

@@ -3,7 +3,7 @@
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from datetime import time
-from typing import Any, final, override
+from typing import Generic, TypeVar, final, override
 
 from eheimdigital.classic_vario import EheimDigitalClassicVario
 from eheimdigital.device import EheimDigitalDevice
@@ -19,13 +19,15 @@ from .entity import EheimDigitalEntity, exception_handler
 
 PARALLEL_UPDATES = 0
 
+_DeviceT_co = TypeVar("_DeviceT_co", bound=EheimDigitalDevice, covariant=True)
+
 
 @dataclass(frozen=True, kw_only=True)
-class EheimDigitalTimeDescription[_DeviceT: EheimDigitalDevice](TimeEntityDescription):
+class EheimDigitalTimeDescription(TimeEntityDescription, Generic[_DeviceT_co]):
     """Class describing EHEIM Digital time entities."""
 
-    value_fn: Callable[[_DeviceT], time | None]
-    set_value_fn: Callable[[_DeviceT, time], Awaitable[None]]
+    value_fn: Callable[[_DeviceT_co], time | None]
+    set_value_fn: Callable[[_DeviceT_co, time], Awaitable[None]]
 
 
 CLASSICVARIO_DESCRIPTIONS: tuple[
@@ -77,7 +79,7 @@ async def async_setup_entry(
         device_address: dict[str, EheimDigitalDevice],
     ) -> None:
         """Set up the time entities for one or multiple devices."""
-        entities: list[EheimDigitalTime[Any]] = []
+        entities: list[EheimDigitalTime[EheimDigitalDevice]] = []
         for device in device_address.values():
             if isinstance(device, EheimDigitalClassicVario):
                 entities.extend(
@@ -101,18 +103,18 @@ async def async_setup_entry(
 
 
 @final
-class EheimDigitalTime[_DeviceT: EheimDigitalDevice](
-    EheimDigitalEntity[_DeviceT], TimeEntity
+class EheimDigitalTime(
+    EheimDigitalEntity[_DeviceT_co], TimeEntity, Generic[_DeviceT_co]
 ):
     """Represent an EHEIM Digital time entity."""
 
-    entity_description: EheimDigitalTimeDescription[_DeviceT]
+    entity_description: EheimDigitalTimeDescription[_DeviceT_co]
 
     def __init__(
         self,
         coordinator: EheimDigitalUpdateCoordinator,
-        device: _DeviceT,
-        description: EheimDigitalTimeDescription[_DeviceT],
+        device: _DeviceT_co,
+        description: EheimDigitalTimeDescription[_DeviceT_co],
     ) -> None:
         """Initialize an EHEIM Digital time entity."""
         super().__init__(coordinator, device)

homeassistant/components/elkm1/services.py

@@ -63,7 +63,6 @@ def _set_time_service(service: ServiceCall) -> None:
     _async_get_elk_panel(service).set_time(dt_util.now())
 
 
-@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Create ElkM1 services."""
 

homeassistant/components/eq3btsmart/__init__.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 
 from eq3btsmart import Thermostat
 from eq3btsmart.exceptions import Eq3Exception
+from eq3btsmart.thermostat_config import ThermostatConfig
 
 from homeassistant.components import bluetooth
 from homeassistant.config_entries import ConfigEntry
@@ -52,7 +53,12 @@ async def async_setup_entry(hass: HomeAssistant, entry: Eq3ConfigEntry) -> bool:
             f"[{eq3_config.mac_address}] Device could not be found"
         )
 
-    thermostat = Thermostat(mac_address=device)  # type: ignore[arg-type]
+    thermostat = Thermostat(
+        thermostat_config=ThermostatConfig(
+            mac_address=mac_address,
+        ),
+        ble_device=device,
+    )
 
     entry.runtime_data = Eq3ConfigEntryData(
         eq3_config=eq3_config, thermostat=thermostat

homeassistant/components/eq3btsmart/binary_sensor.py

@@ -2,6 +2,7 @@
 
 from collections.abc import Callable
 from dataclasses import dataclass
+from typing import TYPE_CHECKING
 
 from eq3btsmart.models import Status
 
@@ -79,4 +80,7 @@ class Eq3BinarySensorEntity(Eq3Entity, BinarySensorEntity):
     def is_on(self) -> bool:
         """Return the state of the binary sensor."""
 
+        if TYPE_CHECKING:
+            assert self._thermostat.status is not None
+
         return self.entity_description.value_func(self._thermostat.status)

homeassistant/components/eq3btsmart/climate.py

@@ -1,16 +1,9 @@
 """Platform for eQ-3 climate entities."""
 
-from datetime import timedelta
 import logging
 from typing import Any
 
-from eq3btsmart.const import (
-    EQ3_DEFAULT_AWAY_TEMP,
-    EQ3_MAX_TEMP,
-    EQ3_OFF_TEMP,
-    Eq3OperationMode,
-    Eq3Preset,
-)
+from eq3btsmart.const import EQ3BT_MAX_TEMP, EQ3BT_OFF_TEMP, Eq3Preset, OperationMode
 from eq3btsmart.exceptions import Eq3Exception
 
 from homeassistant.components.climate import (
@@ -27,11 +20,9 @@ from homeassistant.exceptions import ServiceValidationError
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import CONNECTION_BLUETOOTH
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-import homeassistant.util.dt as dt_util
 
 from . import Eq3ConfigEntry
 from .const import (
-    DEFAULT_AWAY_HOURS,
     EQ_TO_HA_HVAC,
     HA_TO_EQ_HVAC,
     CurrentTemperatureSelector,
@@ -66,8 +57,8 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
         | ClimateEntityFeature.TURN_ON
     )
     _attr_temperature_unit = UnitOfTemperature.CELSIUS
-    _attr_min_temp = EQ3_OFF_TEMP
-    _attr_max_temp = EQ3_MAX_TEMP
+    _attr_min_temp = EQ3BT_OFF_TEMP
+    _attr_max_temp = EQ3BT_MAX_TEMP
     _attr_precision = PRECISION_HALVES
     _attr_hvac_modes = list(HA_TO_EQ_HVAC.keys())
     _attr_preset_modes = list(Preset)
@@ -79,21 +70,38 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
     _target_temperature: float | None = None
 
     @callback
-    def _async_on_status_updated(self, data: Any) -> None:
+    def _async_on_updated(self) -> None:
+        """Handle updated data from the thermostat."""
+
+        if self._thermostat.status is not None:
+            self._async_on_status_updated()
+
+        if self._thermostat.device_data is not None:
+            self._async_on_device_updated()
+
+        super()._async_on_updated()
+
+    @callback
+    def _async_on_status_updated(self) -> None:
         """Handle updated status from the thermostat."""
 
-        self._target_temperature = self._thermostat.status.target_temperature
+        if self._thermostat.status is None:
+            return
+
+        self._target_temperature = self._thermostat.status.target_temperature.value
         self._attr_hvac_mode = EQ_TO_HA_HVAC[self._thermostat.status.operation_mode]
         self._attr_current_temperature = self._get_current_temperature()
         self._attr_target_temperature = self._get_target_temperature()
         self._attr_preset_mode = self._get_current_preset_mode()
         self._attr_hvac_action = self._get_current_hvac_action()
-        super()._async_on_status_updated(data)
 
     @callback
-    def _async_on_device_updated(self, data: Any) -> None:
+    def _async_on_device_updated(self) -> None:
         """Handle updated device data from the thermostat."""
 
+        if self._thermostat.device_data is None:
+            return
+
         device_registry = dr.async_get(self.hass)
         if device := device_registry.async_get_device(
             connections={(CONNECTION_BLUETOOTH, self._eq3_config.mac_address)},
@@ -101,9 +109,8 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
             device_registry.async_update_device(
                 device.id,
                 sw_version=str(self._thermostat.device_data.firmware_version),
-                serial_number=self._thermostat.device_data.device_serial,
+                serial_number=self._thermostat.device_data.device_serial.value,
             )
-        super()._async_on_device_updated(data)
 
     def _get_current_temperature(self) -> float | None:
         """Return the current temperature."""
@@ -112,11 +119,17 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
             case CurrentTemperatureSelector.NOTHING:
                 return None
             case CurrentTemperatureSelector.VALVE:
+                if self._thermostat.status is None:
+                    return None
+
                 return float(self._thermostat.status.valve_temperature)
             case CurrentTemperatureSelector.UI:
                 return self._target_temperature
             case CurrentTemperatureSelector.DEVICE:
-                return float(self._thermostat.status.target_temperature)
+                if self._thermostat.status is None:
+                    return None
+
+                return float(self._thermostat.status.target_temperature.value)
             case CurrentTemperatureSelector.ENTITY:
                 state = self.hass.states.get(self._eq3_config.external_temp_sensor)
                 if state is not None:
@@ -134,12 +147,16 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
             case TargetTemperatureSelector.TARGET:
                 return self._target_temperature
             case TargetTemperatureSelector.LAST_REPORTED:
-                return float(self._thermostat.status.target_temperature)
+                if self._thermostat.status is None:
+                    return None
+
+                return float(self._thermostat.status.target_temperature.value)
 
     def _get_current_preset_mode(self) -> str:
         """Return the current preset mode."""
 
-        status = self._thermostat.status
+        if (status := self._thermostat.status) is None:
+            return PRESET_NONE
         if status.is_window_open:
             return Preset.WINDOW_OPEN
         if status.is_boost:
@@ -148,7 +165,7 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
             return Preset.LOW_BATTERY
         if status.is_away:
             return Preset.AWAY
-        if status.operation_mode is Eq3OperationMode.ON:
+        if status.operation_mode is OperationMode.ON:
             return Preset.OPEN
         if status.presets is None:
             return PRESET_NONE
@@ -162,7 +179,10 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
     def _get_current_hvac_action(self) -> HVACAction:
         """Return the current hvac action."""
 
-        if self._thermostat.status.operation_mode is Eq3OperationMode.OFF:
+        if (
+            self._thermostat.status is None
+            or self._thermostat.status.operation_mode is OperationMode.OFF
+        ):
             return HVACAction.OFF
         if self._thermostat.status.valve == 0:
             return HVACAction.IDLE
@@ -207,7 +227,7 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
         """Set new target hvac mode."""
 
         if hvac_mode is HVACMode.OFF:
-            await self.async_set_temperature(temperature=EQ3_OFF_TEMP)
+            await self.async_set_temperature(temperature=EQ3BT_OFF_TEMP)
 
         try:
             await self._thermostat.async_set_mode(HA_TO_EQ_HVAC[hvac_mode])
@@ -221,11 +241,10 @@ class Eq3Climate(Eq3Entity, ClimateEntity):
             case Preset.BOOST:
                 await self._thermostat.async_set_boost(True)
             case Preset.AWAY:
-                away_until = dt_util.now() + timedelta(hours=DEFAULT_AWAY_HOURS)
-                await self._thermostat.async_set_away(away_until, EQ3_DEFAULT_AWAY_TEMP)
+                await self._thermostat.async_set_away(True)
             case Preset.ECO:
                 await self._thermostat.async_set_preset(Eq3Preset.ECO)
             case Preset.COMFORT:
                 await self._thermostat.async_set_preset(Eq3Preset.COMFORT)
             case Preset.OPEN:
-                await self._thermostat.async_set_mode(Eq3OperationMode.ON)
+                await self._thermostat.async_set_mode(OperationMode.ON)

homeassistant/components/eq3btsmart/const.py

@@ -2,7 +2,7 @@
 
 from enum import Enum
 
-from eq3btsmart.const import Eq3OperationMode
+from eq3btsmart.const import OperationMode
 
 from homeassistant.components.climate import (
     PRESET_AWAY,
@@ -34,17 +34,17 @@ ENTITY_KEY_AWAY_UNTIL = "away_until"
 
 GET_DEVICE_TIMEOUT = 5  # seconds
 
-EQ_TO_HA_HVAC: dict[Eq3OperationMode, HVACMode] = {
-    Eq3OperationMode.OFF: HVACMode.OFF,
-    Eq3OperationMode.ON: HVACMode.HEAT,
-    Eq3OperationMode.AUTO: HVACMode.AUTO,
-    Eq3OperationMode.MANUAL: HVACMode.HEAT,
+EQ_TO_HA_HVAC: dict[OperationMode, HVACMode] = {
+    OperationMode.OFF: HVACMode.OFF,
+    OperationMode.ON: HVACMode.HEAT,
+    OperationMode.AUTO: HVACMode.AUTO,
+    OperationMode.MANUAL: HVACMode.HEAT,
 }
 
 HA_TO_EQ_HVAC = {
-    HVACMode.OFF: Eq3OperationMode.OFF,
-    HVACMode.AUTO: Eq3OperationMode.AUTO,
-    HVACMode.HEAT: Eq3OperationMode.MANUAL,
+    HVACMode.OFF: OperationMode.OFF,
+    HVACMode.AUTO: OperationMode.AUTO,
+    HVACMode.HEAT: OperationMode.MANUAL,
 }
 
 
@@ -81,7 +81,6 @@ class TargetTemperatureSelector(str, Enum):
 DEFAULT_CURRENT_TEMP_SELECTOR = CurrentTemperatureSelector.DEVICE
 DEFAULT_TARGET_TEMP_SELECTOR = TargetTemperatureSelector.TARGET
 DEFAULT_SCAN_INTERVAL = 10  # seconds
-DEFAULT_AWAY_HOURS = 30 * 24
 
 SIGNAL_THERMOSTAT_DISCONNECTED = f"{DOMAIN}.thermostat_disconnected"
 SIGNAL_THERMOSTAT_CONNECTED = f"{DOMAIN}.thermostat_connected"

homeassistant/components/eq3btsmart/entity.py

@@ -1,10 +1,5 @@
 """Base class for all eQ-3 entities."""
 
-from typing import Any
-
-from eq3btsmart import Eq3Exception
-from eq3btsmart.const import Eq3Event
-
 from homeassistant.core import callback
 from homeassistant.helpers.device_registry import (
     CONNECTION_BLUETOOTH,
@@ -50,15 +45,7 @@ class Eq3Entity(Entity):
     async def async_added_to_hass(self) -> None:
         """Run when entity about to be added to hass."""
 
-        self._thermostat.register_callback(
-            Eq3Event.DEVICE_DATA_RECEIVED, self._async_on_device_updated
-        )
-        self._thermostat.register_callback(
-            Eq3Event.STATUS_RECEIVED, self._async_on_status_updated
-        )
-        self._thermostat.register_callback(
-            Eq3Event.SCHEDULE_RECEIVED, self._async_on_status_updated
-        )
+        self._thermostat.register_update_callback(self._async_on_updated)
 
         self.async_on_remove(
             async_dispatcher_connect(
@@ -78,25 +65,10 @@ class Eq3Entity(Entity):
     async def async_will_remove_from_hass(self) -> None:
         """Run when entity will be removed from hass."""
 
-        self._thermostat.unregister_callback(
-            Eq3Event.DEVICE_DATA_RECEIVED, self._async_on_device_updated
-        )
-        self._thermostat.unregister_callback(
-            Eq3Event.STATUS_RECEIVED, self._async_on_status_updated
-        )
-        self._thermostat.unregister_callback(
-            Eq3Event.SCHEDULE_RECEIVED, self._async_on_status_updated
-        )
+        self._thermostat.unregister_update_callback(self._async_on_updated)
 
-    @callback
-    def _async_on_status_updated(self, data: Any) -> None:
-        """Handle updated status from the thermostat."""
-
-        self.async_write_ha_state()
-
-    @callback
-    def _async_on_device_updated(self, data: Any) -> None:
-        """Handle updated device data from the thermostat."""
+    def _async_on_updated(self) -> None:
+        """Handle updated data from the thermostat."""
 
         self.async_write_ha_state()
 
@@ -118,9 +90,4 @@ class Eq3Entity(Entity):
     def available(self) -> bool:
         """Whether the entity is available."""
 
-        try:
-            _ = self._thermostat.status
-        except Eq3Exception:
-            return False
-
-        return self._attr_available
+        return self._thermostat.status is not None and self._attr_available

homeassistant/components/eq3btsmart/manifest.json

@@ -22,5 +22,5 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["eq3btsmart"],
-  "requirements": ["eq3btsmart==2.1.0", "bleak-esphome==2.16.0"]
+  "requirements": ["eq3btsmart==1.4.1", "bleak-esphome==2.16.0"]
 }

homeassistant/components/eq3btsmart/number.py

@@ -1,12 +1,17 @@
 """Platform for eq3 number entities."""
 
-from collections.abc import Callable, Coroutine
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from eq3btsmart import Thermostat
-from eq3btsmart.const import EQ3_MAX_OFFSET, EQ3_MAX_TEMP, EQ3_MIN_OFFSET, EQ3_MIN_TEMP
-from eq3btsmart.models import Presets, Status
+from eq3btsmart.const import (
+    EQ3BT_MAX_OFFSET,
+    EQ3BT_MAX_TEMP,
+    EQ3BT_MIN_OFFSET,
+    EQ3BT_MIN_TEMP,
+)
+from eq3btsmart.models import Presets
 
 from homeassistant.components.number import (
     NumberDeviceClass,
@@ -37,7 +42,7 @@ class Eq3NumberEntityDescription(NumberEntityDescription):
     value_func: Callable[[Presets], float]
     value_set_func: Callable[
         [Thermostat],
-        Callable[[float], Coroutine[None, None, Status]],
+        Callable[[float], Awaitable[None]],
     ]
     mode: NumberMode = NumberMode.BOX
     entity_category: EntityCategory | None = EntityCategory.CONFIG
@@ -46,44 +51,44 @@ class Eq3NumberEntityDescription(NumberEntityDescription):
 NUMBER_ENTITY_DESCRIPTIONS = [
     Eq3NumberEntityDescription(
         key=ENTITY_KEY_COMFORT,
-        value_func=lambda presets: presets.comfort_temperature,
+        value_func=lambda presets: presets.comfort_temperature.value,
         value_set_func=lambda thermostat: thermostat.async_configure_comfort_temperature,
         translation_key=ENTITY_KEY_COMFORT,
-        native_min_value=EQ3_MIN_TEMP,
-        native_max_value=EQ3_MAX_TEMP,
+        native_min_value=EQ3BT_MIN_TEMP,
+        native_max_value=EQ3BT_MAX_TEMP,
         native_step=EQ3BT_STEP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=NumberDeviceClass.TEMPERATURE,
     ),
     Eq3NumberEntityDescription(
         key=ENTITY_KEY_ECO,
-        value_func=lambda presets: presets.eco_temperature,
+        value_func=lambda presets: presets.eco_temperature.value,
         value_set_func=lambda thermostat: thermostat.async_configure_eco_temperature,
         translation_key=ENTITY_KEY_ECO,
-        native_min_value=EQ3_MIN_TEMP,
-        native_max_value=EQ3_MAX_TEMP,
+        native_min_value=EQ3BT_MIN_TEMP,
+        native_max_value=EQ3BT_MAX_TEMP,
         native_step=EQ3BT_STEP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=NumberDeviceClass.TEMPERATURE,
     ),
     Eq3NumberEntityDescription(
         key=ENTITY_KEY_WINDOW_OPEN_TEMPERATURE,
-        value_func=lambda presets: presets.window_open_temperature,
+        value_func=lambda presets: presets.window_open_temperature.value,
         value_set_func=lambda thermostat: thermostat.async_configure_window_open_temperature,
         translation_key=ENTITY_KEY_WINDOW_OPEN_TEMPERATURE,
-        native_min_value=EQ3_MIN_TEMP,
-        native_max_value=EQ3_MAX_TEMP,
+        native_min_value=EQ3BT_MIN_TEMP,
+        native_max_value=EQ3BT_MAX_TEMP,
         native_step=EQ3BT_STEP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=NumberDeviceClass.TEMPERATURE,
     ),
     Eq3NumberEntityDescription(
         key=ENTITY_KEY_OFFSET,
-        value_func=lambda presets: presets.offset_temperature,
+        value_func=lambda presets: presets.offset_temperature.value,
         value_set_func=lambda thermostat: thermostat.async_configure_temperature_offset,
         translation_key=ENTITY_KEY_OFFSET,
-        native_min_value=EQ3_MIN_OFFSET,
-        native_max_value=EQ3_MAX_OFFSET,
+        native_min_value=EQ3BT_MIN_OFFSET,
+        native_max_value=EQ3BT_MAX_OFFSET,
         native_step=EQ3BT_STEP,
         native_unit_of_measurement=UnitOfTemperature.CELSIUS,
         device_class=NumberDeviceClass.TEMPERATURE,
@@ -91,7 +96,7 @@ NUMBER_ENTITY_DESCRIPTIONS = [
     Eq3NumberEntityDescription(
         key=ENTITY_KEY_WINDOW_OPEN_TIMEOUT,
         value_set_func=lambda thermostat: thermostat.async_configure_window_open_duration,
-        value_func=lambda presets: presets.window_open_time.total_seconds() / 60,
+        value_func=lambda presets: presets.window_open_time.value.total_seconds() / 60,
         translation_key=ENTITY_KEY_WINDOW_OPEN_TIMEOUT,
         native_min_value=0,
         native_max_value=60,
@@ -132,6 +137,7 @@ class Eq3NumberEntity(Eq3Entity, NumberEntity):
         """Return the state of the entity."""
 
         if TYPE_CHECKING:
+            assert self._thermostat.status is not None
             assert self._thermostat.status.presets is not None
 
         return self.entity_description.value_func(self._thermostat.status.presets)
@@ -146,7 +152,7 @@ class Eq3NumberEntity(Eq3Entity, NumberEntity):
         """Return whether the entity is available."""
 
         return (
-            super().available
+            self._thermostat.status is not None
             and self._thermostat.status.presets is not None
             and self._attr_available
         )

homeassistant/components/eq3btsmart/schemas.py

@@ -1,12 +1,12 @@
 """Voluptuous schemas for eq3btsmart."""
 
-from eq3btsmart.const import EQ3_MAX_TEMP, EQ3_MIN_TEMP
+from eq3btsmart.const import EQ3BT_MAX_TEMP, EQ3BT_MIN_TEMP
 import voluptuous as vol
 
 from homeassistant.const import CONF_MAC
 from homeassistant.helpers import config_validation as cv
 
-SCHEMA_TEMPERATURE = vol.Range(min=EQ3_MIN_TEMP, max=EQ3_MAX_TEMP)
+SCHEMA_TEMPERATURE = vol.Range(min=EQ3BT_MIN_TEMP, max=EQ3BT_MAX_TEMP)
 SCHEMA_DEVICE = vol.Schema({vol.Required(CONF_MAC): cv.string})
 SCHEMA_MAC = vol.Schema(
     {

homeassistant/components/eq3btsmart/sensor.py

@@ -3,6 +3,7 @@
 from collections.abc import Callable
 from dataclasses import dataclass
 from datetime import datetime
+from typing import TYPE_CHECKING
 
 from eq3btsmart.models import Status
 
@@ -39,7 +40,9 @@ SENSOR_ENTITY_DESCRIPTIONS = [
     Eq3SensorEntityDescription(
         key=ENTITY_KEY_AWAY_UNTIL,
         translation_key=ENTITY_KEY_AWAY_UNTIL,
-        value_func=lambda status: (status.away_until if status.away_until else None),
+        value_func=lambda status: (
+            status.away_until.value if status.away_until else None
+        ),
         device_class=SensorDeviceClass.DATE,
     ),
 ]
@@ -75,4 +78,7 @@ class Eq3SensorEntity(Eq3Entity, SensorEntity):
     def native_value(self) -> int | datetime | None:
         """Return the value reported by the sensor."""
 
+        if TYPE_CHECKING:
+            assert self._thermostat.status is not None
+
         return self.entity_description.value_func(self._thermostat.status)

homeassistant/components/eq3btsmart/switch.py

@@ -1,45 +1,26 @@
 """Platform for eq3 switch entities."""
 
-from collections.abc import Callable, Coroutine
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
-from datetime import timedelta
-from functools import partial
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from eq3btsmart import Thermostat
-from eq3btsmart.const import EQ3_DEFAULT_AWAY_TEMP, Eq3OperationMode
 from eq3btsmart.models import Status
 
 from homeassistant.components.switch import SwitchEntity, SwitchEntityDescription
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-import homeassistant.util.dt as dt_util
 
 from . import Eq3ConfigEntry
-from .const import (
-    DEFAULT_AWAY_HOURS,
-    ENTITY_KEY_AWAY,
-    ENTITY_KEY_BOOST,
-    ENTITY_KEY_LOCK,
-)
+from .const import ENTITY_KEY_AWAY, ENTITY_KEY_BOOST, ENTITY_KEY_LOCK
 from .entity import Eq3Entity
 
 
-async def async_set_away(thermostat: Thermostat, enable: bool) -> Status:
-    """Backport old async_set_away behavior."""
-
-    if not enable:
-        return await thermostat.async_set_mode(Eq3OperationMode.AUTO)
-
-    away_until = dt_util.now() + timedelta(hours=DEFAULT_AWAY_HOURS)
-    return await thermostat.async_set_away(away_until, EQ3_DEFAULT_AWAY_TEMP)
-
-
 @dataclass(frozen=True, kw_only=True)
 class Eq3SwitchEntityDescription(SwitchEntityDescription):
     """Entity description for eq3 switch entities."""
 
-    toggle_func: Callable[[Thermostat], Callable[[bool], Coroutine[None, None, Status]]]
+    toggle_func: Callable[[Thermostat], Callable[[bool], Awaitable[None]]]
     value_func: Callable[[Status], bool]
 
 
@@ -59,7 +40,7 @@ SWITCH_ENTITY_DESCRIPTIONS = [
     Eq3SwitchEntityDescription(
         key=ENTITY_KEY_AWAY,
         translation_key=ENTITY_KEY_AWAY,
-        toggle_func=lambda thermostat: partial(async_set_away, thermostat),
+        toggle_func=lambda thermostat: thermostat.async_set_away,
         value_func=lambda status: status.is_away,
     ),
 ]
@@ -107,4 +88,7 @@ class Eq3SwitchEntity(Eq3Entity, SwitchEntity):
     def is_on(self) -> bool:
         """Return the state of the switch."""
 
+        if TYPE_CHECKING:
+            assert self._thermostat.status is not None
+
         return self.entity_description.value_func(self._thermostat.status)

homeassistant/components/esphome/assist_satellite.py

@@ -60,7 +60,6 @@ _VOICE_ASSISTANT_EVENT_TYPES: EsphomeEnumMapper[
         VoiceAssistantEventType.VOICE_ASSISTANT_STT_START: PipelineEventType.STT_START,
         VoiceAssistantEventType.VOICE_ASSISTANT_STT_END: PipelineEventType.STT_END,
         VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_START: PipelineEventType.INTENT_START,
-        VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_PROGRESS: PipelineEventType.INTENT_PROGRESS,
         VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_END: PipelineEventType.INTENT_END,
         VoiceAssistantEventType.VOICE_ASSISTANT_TTS_START: PipelineEventType.TTS_START,
         VoiceAssistantEventType.VOICE_ASSISTANT_TTS_END: PipelineEventType.TTS_END,
@@ -283,12 +282,6 @@ class EsphomeAssistSatellite(
         elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_STT_END:
             assert event.data is not None
             data_to_send = {"text": event.data["stt_output"]["text"]}
-        elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_PROGRESS:
-            data_to_send = {
-                "tts_start_streaming": "1"
-                if (event.data and event.data.get("tts_start_streaming"))
-                else "0",
-            }
         elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_INTENT_END:
             assert event.data is not None
             data_to_send = {
@@ -339,7 +332,7 @@ class EsphomeAssistSatellite(
             }
         elif event_type == VoiceAssistantEventType.VOICE_ASSISTANT_RUN_START:
             assert event.data is not None
-            if tts_output := event.data.get("tts_output"):
+            if tts_output := event.data["tts_output"]:
                 path = tts_output["url"]
                 url = async_process_play_media_url(self.hass, path)
                 data_to_send = {"url": url}

homeassistant/components/esphome/dashboard.py

@@ -63,7 +63,9 @@ class ESPHomeDashboardManager:
         if not (data := self._data) or not (info := data.get("info")):
             return
         if is_hassio(self._hass):
-            from homeassistant.components.hassio import get_addons_info  # noqa: PLC0415
+            from homeassistant.components.hassio import (  # pylint: disable=import-outside-toplevel
+                get_addons_info,
+            )
 
             if (addons := get_addons_info(self._hass)) is not None and info[
                 "addon_slug"

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==32.2.4",
+    "aioesphomeapi==32.2.1",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==2.16.0"
   ],

homeassistant/components/ffmpeg/services.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import voluptuous as vol
 
 from homeassistant.const import ATTR_ENTITY_ID
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_send
 
@@ -35,7 +35,6 @@ async def _async_service_handle(service: ServiceCall) -> None:
         async_dispatcher_send(service.hass, SIGNAL_FFMPEG_RESTART, entity_ids)
 
 
-@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Register FFmpeg services."""
 

homeassistant/components/frontend/__init__.py

@@ -364,7 +364,8 @@ def _frontend_root(dev_repo_path: str | None) -> pathlib.Path:
     if dev_repo_path is not None:
         return pathlib.Path(dev_repo_path) / "hass_frontend"
     # Keep import here so that we can import frontend without installing reqs
-    import hass_frontend  # noqa: PLC0415
+    # pylint: disable-next=import-outside-toplevel
+    import hass_frontend
 
     return hass_frontend.where()
 

homeassistant/components/frontend/manifest.json

@@ -20,5 +20,5 @@
   "documentation": "https://www.home-assistant.io/integrations/frontend",
   "integration_type": "system",
   "quality_scale": "internal",
-  "requirements": ["home-assistant-frontend==20250531.3"]
+  "requirements": ["home-assistant-frontend==20250531.2"]
 }

homeassistant/components/go2rtc/__init__.py

@@ -1,11 +1,8 @@
 """The go2rtc component."""
 
-from __future__ import annotations
-
 import logging
 import shutil
 
-from aiohttp import ClientSession
 from aiohttp.client_exceptions import ClientConnectionError, ServerConnectionError
 from awesomeversion import AwesomeVersion
 from go2rtc_client import Go2RtcRestClient
@@ -35,7 +32,7 @@ from homeassistant.components.default_config import DOMAIN as DEFAULT_CONFIG_DOM
 from homeassistant.config_entries import SOURCE_SYSTEM, ConfigEntry
 from homeassistant.const import CONF_URL, EVENT_HOMEASSISTANT_STOP
 from homeassistant.core import Event, HomeAssistant, callback
-from homeassistant.exceptions import ConfigEntryNotReady, HomeAssistantError
+from homeassistant.exceptions import ConfigEntryNotReady
 from homeassistant.helpers import (
     config_validation as cv,
     discovery_flow,
@@ -101,7 +98,6 @@ CONFIG_SCHEMA = vol.Schema(
 
 _DATA_GO2RTC: HassKey[str] = HassKey(DOMAIN)
 _RETRYABLE_ERRORS = (ClientConnectionError, ServerConnectionError)
-type Go2RtcConfigEntry = ConfigEntry[WebRTCProvider]
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
@@ -155,14 +151,13 @@ async def _remove_go2rtc_entries(hass: HomeAssistant) -> None:
         await hass.config_entries.async_remove(entry.entry_id)
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: Go2RtcConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up go2rtc from a config entry."""
-
     url = hass.data[_DATA_GO2RTC]
-    session = async_get_clientsession(hass)
-    client = Go2RtcRestClient(session, url)
+
     # Validate the server URL
     try:
+        client = Go2RtcRestClient(async_get_clientsession(hass), url)
         version = await client.validate_server_version()
         if version < AwesomeVersion(RECOMMENDED_VERSION):
             ir.async_create_issue(
@@ -193,14 +188,13 @@ async def async_setup_entry(hass: HomeAssistant, entry: Go2RtcConfigEntry) -> bo
         _LOGGER.warning("Could not connect to go2rtc instance on %s (%s)", url, err)
         return False
 
-    provider = entry.runtime_data = WebRTCProvider(hass, url, session, client)
-    entry.async_on_unload(async_register_webrtc_provider(hass, provider))
+    provider = WebRTCProvider(hass, url)
+    async_register_webrtc_provider(hass, provider)
     return True
 
 
-async def async_unload_entry(hass: HomeAssistant, entry: Go2RtcConfigEntry) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a go2rtc config entry."""
-    await entry.runtime_data.teardown()
     return True
 
 
@@ -212,18 +206,12 @@ async def _get_binary(hass: HomeAssistant) -> str | None:
 class WebRTCProvider(CameraWebRTCProvider):
     """WebRTC provider."""
 
-    def __init__(
-        self,
-        hass: HomeAssistant,
-        url: str,
-        session: ClientSession,
-        rest_client: Go2RtcRestClient,
-    ) -> None:
+    def __init__(self, hass: HomeAssistant, url: str) -> None:
         """Initialize the WebRTC provider."""
         self._hass = hass
         self._url = url
-        self._session = session
-        self._rest_client = rest_client
+        self._session = async_get_clientsession(hass)
+        self._rest_client = Go2RtcRestClient(self._session, url)
         self._sessions: dict[str, Go2RtcWsClient] = {}
 
     @property
@@ -244,16 +232,32 @@ class WebRTCProvider(CameraWebRTCProvider):
         send_message: WebRTCSendMessage,
     ) -> None:
         """Handle the WebRTC offer and return the answer via the provided callback."""
-        try:
-            await self._update_stream_source(camera)
-        except HomeAssistantError as err:
-            send_message(WebRTCError("go2rtc_webrtc_offer_failed", str(err)))
-            return
-
         self._sessions[session_id] = ws_client = Go2RtcWsClient(
             self._session, self._url, source=camera.entity_id
         )
 
+        if not (stream_source := await camera.stream_source()):
+            send_message(
+                WebRTCError("go2rtc_webrtc_offer_failed", "Camera has no stream source")
+            )
+            return
+
+        streams = await self._rest_client.streams.list()
+
+        if (stream := streams.get(camera.entity_id)) is None or not any(
+            stream_source == producer.url for producer in stream.producers
+        ):
+            await self._rest_client.streams.add(
+                camera.entity_id,
+                [
+                    stream_source,
+                    # We are setting any ffmpeg rtsp related logs to debug
+                    # Connection problems to the camera will be logged by the first stream
+                    # Therefore setting it to debug will not hide any important logs
+                    f"ffmpeg:{camera.entity_id}#audio=opus#query=log_level=debug",
+                ],
+            )
+
         @callback
         def on_messages(message: ReceiveMessages) -> None:
             """Handle messages."""
@@ -287,48 +291,3 @@ class WebRTCProvider(CameraWebRTCProvider):
         """Close the session."""
         ws_client = self._sessions.pop(session_id)
         self._hass.async_create_task(ws_client.close())
-
-    async def async_get_image(
-        self,
-        camera: Camera,
-        width: int | None = None,
-        height: int | None = None,
-    ) -> bytes | None:
-        """Get an image from the camera."""
-        await self._update_stream_source(camera)
-        return await self._rest_client.get_jpeg_snapshot(
-            camera.entity_id, width, height
-        )
-
-    async def _update_stream_source(self, camera: Camera) -> None:
-        """Update the stream source in go2rtc config if needed."""
-        if not (stream_source := await camera.stream_source()):
-            await self.teardown()
-            raise HomeAssistantError("Camera has no stream source")
-
-        if not self.async_is_supported(stream_source):
-            await self.teardown()
-            raise HomeAssistantError("Stream source is not supported by go2rtc")
-
-        streams = await self._rest_client.streams.list()
-
-        if (stream := streams.get(camera.entity_id)) is None or not any(
-            stream_source == producer.url for producer in stream.producers
-        ):
-            await self._rest_client.streams.add(
-                camera.entity_id,
-                [
-                    stream_source,
-                    # We are setting any ffmpeg rtsp related logs to debug
-                    # Connection problems to the camera will be logged by the first stream
-                    # Therefore setting it to debug will not hide any important logs
-                    f"ffmpeg:{camera.entity_id}#audio=opus#query=log_level=debug",
-                    f"ffmpeg:{camera.entity_id}#video=mjpeg",
-                ],
-            )
-
-    async def teardown(self) -> None:
-        """Tear down the provider."""
-        for ws_client in self._sessions.values():
-            await ws_client.close()
-        self._sessions.clear()

homeassistant/components/goalzero/sensor.py

@@ -109,7 +109,6 @@ SENSOR_TYPES: tuple[SensorEntityDescription, ...] = (
     SensorEntityDescription(
         key="timestamp",
         translation_key="timestamp",
-        device_class=SensorDeviceClass.DURATION,
         native_unit_of_measurement=UnitOfTime.SECONDS,
         entity_registry_enabled_default=False,
         entity_category=EntityCategory.DIAGNOSTIC,

homeassistant/components/google/manifest.json

@@ -7,5 +7,5 @@
   "documentation": "https://www.home-assistant.io/integrations/google",
   "iot_class": "cloud_polling",
   "loggers": ["googleapiclient"],
-  "requirements": ["gcal-sync==7.1.0", "oauth2client==4.1.3", "ical==10.0.4"]
+  "requirements": ["gcal-sync==7.1.0", "oauth2client==4.1.3", "ical==10.0.0"]
 }

homeassistant/components/google_assistant/helpers.py

@@ -212,7 +212,8 @@ class AbstractConfig(ABC):
     def async_enable_report_state(self) -> None:
         """Enable proactive mode."""
         # Circular dep
-        from .report_state import async_enable_report_state  # noqa: PLC0415
+        # pylint: disable-next=import-outside-toplevel
+        from .report_state import async_enable_report_state
 
         if self._unsub_report_state is None:
             self._unsub_report_state = async_enable_report_state(self.hass, self)
@@ -394,7 +395,8 @@ class AbstractConfig(ABC):
     async def _handle_local_webhook(self, hass, webhook_id, request):
         """Handle an incoming local SDK message."""
         # Circular dep
-        from . import smart_home  # noqa: PLC0415
+        # pylint: disable-next=import-outside-toplevel
+        from . import smart_home
 
         self._local_last_active = utcnow()
 
@@ -653,9 +655,8 @@ class GoogleEntity:
         if "matter" in self.hass.config.components and any(
             x for x in device_entry.identifiers if x[0] == "matter"
         ):
-            from homeassistant.components.matter import (  # noqa: PLC0415
-                get_matter_device_info,
-            )
+            # pylint: disable-next=import-outside-toplevel
+            from homeassistant.components.matter import get_matter_device_info
 
             # Import matter can block the event loop for multiple seconds
             # so we import it here to avoid blocking the event loop during

homeassistant/components/google_assistant_sdk/services.py

@@ -11,7 +11,6 @@ from homeassistant.core import (
     ServiceCall,
     ServiceResponse,
     SupportsResponse,
-    callback,
 )
 from homeassistant.helpers import config_validation as cv
 
@@ -50,7 +49,6 @@ async def _send_text_command(call: ServiceCall) -> ServiceResponse:
     return None
 
 
-@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Add the services for Google Assistant SDK."""
 

homeassistant/components/google_generative_ai_conversation/__init__.py

@@ -45,10 +45,7 @@ CONF_IMAGE_FILENAME = "image_filename"
 CONF_FILENAMES = "filenames"
 
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
-PLATFORMS = (
-    Platform.CONVERSATION,
-    Platform.TTS,
-)
+PLATFORMS = (Platform.CONVERSATION,)
 
 type GoogleGenerativeAIConfigEntry = ConfigEntry[Client]
 

homeassistant/components/google_generative_ai_conversation/const.py

@@ -6,11 +6,9 @@ DOMAIN = "google_generative_ai_conversation"
 LOGGER = logging.getLogger(__package__)
 CONF_PROMPT = "prompt"
 
-ATTR_MODEL = "model"
 CONF_RECOMMENDED = "recommended"
 CONF_CHAT_MODEL = "chat_model"
 RECOMMENDED_CHAT_MODEL = "models/gemini-2.0-flash"
-RECOMMENDED_TTS_MODEL = "gemini-2.5-flash-preview-tts"
 CONF_TEMPERATURE = "temperature"
 RECOMMENDED_TEMPERATURE = 1.0
 CONF_TOP_P = "top_p"

homeassistant/components/google_generative_ai_conversation/conversation.py

@@ -2,18 +2,63 @@
 
 from __future__ import annotations
 
-from typing import Literal
+import codecs
+from collections.abc import AsyncGenerator, Callable
+from dataclasses import replace
+from typing import Any, Literal, cast
+
+from google.genai.errors import APIError, ClientError
+from google.genai.types import (
+    AutomaticFunctionCallingConfig,
+    Content,
+    FunctionDeclaration,
+    GenerateContentConfig,
+    GenerateContentResponse,
+    GoogleSearch,
+    HarmCategory,
+    Part,
+    SafetySetting,
+    Schema,
+    Tool,
+)
+from voluptuous_openapi import convert
 
 from homeassistant.components import assist_pipeline, conversation
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_LLM_HASS_API, MATCH_ALL
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import intent
+from homeassistant.helpers import device_registry as dr, intent, llm
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from .const import CONF_PROMPT, DOMAIN, LOGGER
-from .entity import ERROR_GETTING_RESPONSE, GoogleGenerativeAILLMBaseEntity
+from .const import (
+    CONF_CHAT_MODEL,
+    CONF_DANGEROUS_BLOCK_THRESHOLD,
+    CONF_HARASSMENT_BLOCK_THRESHOLD,
+    CONF_HATE_BLOCK_THRESHOLD,
+    CONF_MAX_TOKENS,
+    CONF_PROMPT,
+    CONF_SEXUAL_BLOCK_THRESHOLD,
+    CONF_TEMPERATURE,
+    CONF_TOP_K,
+    CONF_TOP_P,
+    CONF_USE_GOOGLE_SEARCH_TOOL,
+    DOMAIN,
+    LOGGER,
+    RECOMMENDED_CHAT_MODEL,
+    RECOMMENDED_HARM_BLOCK_THRESHOLD,
+    RECOMMENDED_MAX_TOKENS,
+    RECOMMENDED_TEMPERATURE,
+    RECOMMENDED_TOP_K,
+    RECOMMENDED_TOP_P,
+)
+
+# Max number of back and forth with the LLM to generate a response
+MAX_TOOL_ITERATIONS = 10
+
+ERROR_GETTING_RESPONSE = (
+    "Sorry, I had a problem getting a response from Google Generative AI."
+)
 
 
 async def async_setup_entry(
@@ -26,18 +71,265 @@ async def async_setup_entry(
     async_add_entities([agent])
 
 
+SUPPORTED_SCHEMA_KEYS = {
+    # Gemini API does not support all of the OpenAPI schema
+    # SoT: https://ai.google.dev/api/caching#Schema
+    "type",
+    "format",
+    "description",
+    "nullable",
+    "enum",
+    "max_items",
+    "min_items",
+    "properties",
+    "required",
+    "items",
+}
+
+
+def _camel_to_snake(name: str) -> str:
+    """Convert camel case to snake case."""
+    return "".join(["_" + c.lower() if c.isupper() else c for c in name]).lstrip("_")
+
+
+def _format_schema(schema: dict[str, Any]) -> Schema:
+    """Format the schema to be compatible with Gemini API."""
+    if subschemas := schema.get("allOf"):
+        for subschema in subschemas:  # Gemini API does not support allOf keys
+            if "type" in subschema:  # Fallback to first subschema with 'type' field
+                return _format_schema(subschema)
+        return _format_schema(
+            subschemas[0]
+        )  # Or, if not found, to any of the subschemas
+
+    result = {}
+    for key, val in schema.items():
+        key = _camel_to_snake(key)
+        if key not in SUPPORTED_SCHEMA_KEYS:
+            continue
+        if key == "type":
+            val = val.upper()
+        elif key == "format":
+            # Gemini API does not support all formats, see: https://ai.google.dev/api/caching#Schema
+            # formats that are not supported are ignored
+            if schema.get("type") == "string" and val not in ("enum", "date-time"):
+                continue
+            if schema.get("type") == "number" and val not in ("float", "double"):
+                continue
+            if schema.get("type") == "integer" and val not in ("int32", "int64"):
+                continue
+            if schema.get("type") not in ("string", "number", "integer"):
+                continue
+        elif key == "items":
+            val = _format_schema(val)
+        elif key == "properties":
+            val = {k: _format_schema(v) for k, v in val.items()}
+        result[key] = val
+
+    if result.get("enum") and result.get("type") != "STRING":
+        # enum is only allowed for STRING type. This is safe as long as the schema
+        # contains vol.Coerce for the respective type, for example:
+        # vol.All(vol.Coerce(int), vol.In([1, 2, 3]))
+        result["type"] = "STRING"
+        result["enum"] = [str(item) for item in result["enum"]]
+
+    if result.get("type") == "OBJECT" and not result.get("properties"):
+        # An object with undefined properties is not supported by Gemini API.
+        # Fallback to JSON string. This will probably fail for most tools that want it,
+        # but we don't have a better fallback strategy so far.
+        result["properties"] = {"json": {"type": "STRING"}}
+        result["required"] = []
+    return cast(Schema, result)
+
+
+def _format_tool(
+    tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
+) -> Tool:
+    """Format tool specification."""
+
+    if tool.parameters.schema:
+        parameters = _format_schema(
+            convert(tool.parameters, custom_serializer=custom_serializer)
+        )
+    else:
+        parameters = None
+
+    return Tool(
+        function_declarations=[
+            FunctionDeclaration(
+                name=tool.name,
+                description=tool.description,
+                parameters=parameters,
+            )
+        ]
+    )
+
+
+def _escape_decode(value: Any) -> Any:
+    """Recursively call codecs.escape_decode on all values."""
+    if isinstance(value, str):
+        return codecs.escape_decode(bytes(value, "utf-8"))[0].decode("utf-8")  # type: ignore[attr-defined]
+    if isinstance(value, list):
+        return [_escape_decode(item) for item in value]
+    if isinstance(value, dict):
+        return {k: _escape_decode(v) for k, v in value.items()}
+    return value
+
+
+def _create_google_tool_response_parts(
+    parts: list[conversation.ToolResultContent],
+) -> list[Part]:
+    """Create Google tool response parts."""
+    return [
+        Part.from_function_response(
+            name=tool_result.tool_name, response=tool_result.tool_result
+        )
+        for tool_result in parts
+    ]
+
+
+def _create_google_tool_response_content(
+    content: list[conversation.ToolResultContent],
+) -> Content:
+    """Create a Google tool response content."""
+    return Content(
+        role="user",
+        parts=_create_google_tool_response_parts(content),
+    )
+
+
+def _convert_content(
+    content: conversation.UserContent
+    | conversation.AssistantContent
+    | conversation.SystemContent,
+) -> Content:
+    """Convert HA content to Google content."""
+    if content.role != "assistant" or not content.tool_calls:
+        role = "model" if content.role == "assistant" else content.role
+        return Content(
+            role=role,
+            parts=[
+                Part.from_text(text=content.content if content.content else ""),
+            ],
+        )
+
+    # Handle the Assistant content with tool calls.
+    assert type(content) is conversation.AssistantContent
+    parts: list[Part] = []
+
+    if content.content:
+        parts.append(Part.from_text(text=content.content))
+
+    if content.tool_calls:
+        parts.extend(
+            [
+                Part.from_function_call(
+                    name=tool_call.tool_name,
+                    args=_escape_decode(tool_call.tool_args),
+                )
+                for tool_call in content.tool_calls
+            ]
+        )
+
+    return Content(role="model", parts=parts)
+
+
+async def _transform_stream(
+    result: AsyncGenerator[GenerateContentResponse],
+) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
+    new_message = True
+    try:
+        async for response in result:
+            LOGGER.debug("Received response chunk: %s", response)
+            chunk: conversation.AssistantContentDeltaDict = {}
+
+            if new_message:
+                chunk["role"] = "assistant"
+                new_message = False
+
+            # According to the API docs, this would mean no candidate is returned, so we can safely throw an error here.
+            if response.prompt_feedback or not response.candidates:
+                reason = (
+                    response.prompt_feedback.block_reason_message
+                    if response.prompt_feedback
+                    else "unknown"
+                )
+                raise HomeAssistantError(
+                    f"The message got blocked due to content violations, reason: {reason}"
+                )
+
+            candidate = response.candidates[0]
+
+            if (
+                candidate.finish_reason is not None
+                and candidate.finish_reason != "STOP"
+            ):
+                # The message ended due to a content error as explained in: https://ai.google.dev/api/generate-content#FinishReason
+                LOGGER.error(
+                    "Error in Google Generative AI response: %s, see: https://ai.google.dev/api/generate-content#FinishReason",
+                    candidate.finish_reason,
+                )
+                raise HomeAssistantError(
+                    f"{ERROR_GETTING_RESPONSE} Reason: {candidate.finish_reason}"
+                )
+
+            response_parts = (
+                candidate.content.parts
+                if candidate.content is not None and candidate.content.parts is not None
+                else []
+            )
+
+            content = "".join([part.text for part in response_parts if part.text])
+            tool_calls = []
+            for part in response_parts:
+                if not part.function_call:
+                    continue
+                tool_call = part.function_call
+                tool_name = tool_call.name if tool_call.name else ""
+                tool_args = _escape_decode(tool_call.args)
+                tool_calls.append(
+                    llm.ToolInput(tool_name=tool_name, tool_args=tool_args)
+                )
+
+            if tool_calls:
+                chunk["tool_calls"] = tool_calls
+
+            chunk["content"] = content
+            yield chunk
+    except (
+        APIError,
+        ValueError,
+    ) as err:
+        LOGGER.error("Error sending message: %s %s", type(err), err)
+        if isinstance(err, APIError):
+            message = err.message
+        else:
+            message = type(err).__name__
+        error = f"{ERROR_GETTING_RESPONSE}: {message}"
+        raise HomeAssistantError(error) from err
+
+
 class GoogleGenerativeAIConversationEntity(
-    conversation.ConversationEntity,
-    conversation.AbstractConversationAgent,
-    GoogleGenerativeAILLMBaseEntity,
+    conversation.ConversationEntity, conversation.AbstractConversationAgent
 ):
     """Google Generative AI conversation agent."""
 
+    _attr_has_entity_name = True
+    _attr_name = None
     _attr_supports_streaming = True
 
     def __init__(self, entry: ConfigEntry) -> None:
         """Initialize the agent."""
-        super().__init__(entry)
+        self.entry = entry
+        self._genai_client = entry.runtime_data
+        self._attr_unique_id = entry.entry_id
+        self._attr_device_info = dr.DeviceInfo(
+            identifiers={(DOMAIN, entry.entry_id)},
+            name=entry.title,
+            manufacturer="Google",
+            model="Generative AI",
+            entry_type=dr.DeviceEntryType.SERVICE,
+        )
         if self.entry.options.get(CONF_LLM_HASS_API):
             self._attr_supported_features = (
                 conversation.ConversationEntityFeature.CONTROL
@@ -64,6 +356,13 @@ class GoogleGenerativeAIConversationEntity(
         conversation.async_unset_agent(self.hass, self.entry)
         await super().async_will_remove_from_hass()
 
+    def _fix_tool_name(self, tool_name: str) -> str:
+        """Fix tool name if needed."""
+        # The Gemini 2.0+ tokenizer seemingly has a issue with the HassListAddItem tool
+        # name. This makes sure when it incorrectly changes the name, that we change it
+        # back for HA to call.
+        return tool_name if tool_name != "HasListAddItem" else "HassListAddItem"
+
     async def _async_handle_message(
         self,
         user_input: conversation.ConversationInput,
@@ -73,16 +372,162 @@ class GoogleGenerativeAIConversationEntity(
         options = self.entry.options
 
         try:
-            await chat_log.async_provide_llm_data(
-                user_input.as_llm_context(DOMAIN),
+            await chat_log.async_update_llm_data(
+                DOMAIN,
+                user_input,
                 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)
+        tools: list[Tool | Callable[..., Any]] | None = None
+        if chat_log.llm_api:
+            tools = [
+                _format_tool(tool, chat_log.llm_api.custom_serializer)
+                for tool in chat_log.llm_api.tools
+            ]
+
+        # Using search grounding allows the model to retrieve information from the web,
+        # however, it may interfere with how the model decides to use some tools, or entities
+        # for example weather entity may be disregarded if the model chooses to Google it.
+        if options.get(CONF_USE_GOOGLE_SEARCH_TOOL) is True:
+            tools = tools or []
+            tools.append(Tool(google_search=GoogleSearch()))
+
+        model_name = self.entry.options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
+        # Avoid INVALID_ARGUMENT Developer instruction is not enabled for <model>
+        supports_system_instruction = (
+            "gemma" not in model_name
+            and "gemini-2.0-flash-preview-image-generation" not in model_name
+        )
+
+        prompt_content = cast(
+            conversation.SystemContent,
+            chat_log.content[0],
+        )
+
+        if prompt_content.content:
+            prompt = prompt_content.content
+        else:
+            raise HomeAssistantError("Invalid prompt content")
+
+        messages: list[Content] = []
+
+        # Google groups tool results, we do not. Group them before sending.
+        tool_results: list[conversation.ToolResultContent] = []
+
+        for chat_content in chat_log.content[1:-1]:
+            if chat_content.role == "tool_result":
+                tool_results.append(chat_content)
+                continue
+
+            if (
+                not isinstance(chat_content, conversation.ToolResultContent)
+                and chat_content.content == ""
+            ):
+                # Skipping is not possible since the number of function calls need to match the number of function responses
+                # and skipping one would mean removing the other and hence this would prevent a proper chat log
+                chat_content = replace(chat_content, content=" ")
+
+            if tool_results:
+                messages.append(_create_google_tool_response_content(tool_results))
+                tool_results.clear()
+
+            messages.append(_convert_content(chat_content))
+
+        # The SDK requires the first message to be a user message
+        # This is not the case if user used `start_conversation`
+        # Workaround from https://github.com/googleapis/python-genai/issues/529#issuecomment-2740964537
+        if messages and messages[0].role != "user":
+            messages.insert(
+                0,
+                Content(role="user", parts=[Part.from_text(text=" ")]),
+            )
+
+        if tool_results:
+            messages.append(_create_google_tool_response_content(tool_results))
+        generateContentConfig = GenerateContentConfig(
+            temperature=self.entry.options.get(
+                CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
+            ),
+            top_k=self.entry.options.get(CONF_TOP_K, RECOMMENDED_TOP_K),
+            top_p=self.entry.options.get(CONF_TOP_P, RECOMMENDED_TOP_P),
+            max_output_tokens=self.entry.options.get(
+                CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS
+            ),
+            safety_settings=[
+                SafetySetting(
+                    category=HarmCategory.HARM_CATEGORY_HATE_SPEECH,
+                    threshold=self.entry.options.get(
+                        CONF_HATE_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
+                    ),
+                ),
+                SafetySetting(
+                    category=HarmCategory.HARM_CATEGORY_HARASSMENT,
+                    threshold=self.entry.options.get(
+                        CONF_HARASSMENT_BLOCK_THRESHOLD,
+                        RECOMMENDED_HARM_BLOCK_THRESHOLD,
+                    ),
+                ),
+                SafetySetting(
+                    category=HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
+                    threshold=self.entry.options.get(
+                        CONF_DANGEROUS_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
+                    ),
+                ),
+                SafetySetting(
+                    category=HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
+                    threshold=self.entry.options.get(
+                        CONF_SEXUAL_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
+                    ),
+                ),
+            ],
+            tools=tools or None,
+            system_instruction=prompt if supports_system_instruction else None,
+            automatic_function_calling=AutomaticFunctionCallingConfig(
+                disable=True, maximum_remote_calls=None
+            ),
+        )
+
+        if not supports_system_instruction:
+            messages = [
+                Content(role="user", parts=[Part.from_text(text=prompt)]),
+                Content(role="model", parts=[Part.from_text(text="Ok")]),
+                *messages,
+            ]
+        chat = self._genai_client.aio.chats.create(
+            model=model_name, history=messages, config=generateContentConfig
+        )
+        chat_request: str | list[Part] = user_input.text
+        # To prevent infinite loops, we limit the number of iterations
+        for _iteration in range(MAX_TOOL_ITERATIONS):
+            try:
+                chat_response_generator = await chat.send_message_stream(
+                    message=chat_request
+                )
+            except (
+                APIError,
+                ClientError,
+                ValueError,
+            ) as err:
+                LOGGER.error("Error sending message: %s %s", type(err), err)
+                error = ERROR_GETTING_RESPONSE
+                raise HomeAssistantError(error) from err
+
+            chat_request = _create_google_tool_response_parts(
+                [
+                    content
+                    async for content in chat_log.async_add_delta_content_stream(
+                        user_input.agent_id,
+                        _transform_stream(chat_response_generator),
+                    )
+                    if isinstance(content, conversation.ToolResultContent)
+                ]
+            )
+
+            if not chat_log.unresponded_tool_results:
+                break
 
         response = intent.IntentResponse(language=user_input.language)
         if not isinstance(chat_log.content[-1], conversation.AssistantContent):
@@ -90,7 +535,7 @@ class GoogleGenerativeAIConversationEntity(
                 "Last content in chat log is not an AssistantContent: %s. This could be due to the model not returning a valid response",
                 chat_log.content[-1],
             )
-            raise HomeAssistantError(ERROR_GETTING_RESPONSE)
+            raise HomeAssistantError(f"{ERROR_GETTING_RESPONSE}")
         response.async_set_speech(chat_log.content[-1].content or "")
         return conversation.ConversationResult(
             response=response,

homeassistant/components/google_generative_ai_conversation/entity.py

@@ -1,475 +0,0 @@
-"""Conversation support for the Google Generative AI Conversation integration."""
-
-from __future__ import annotations
-
-import codecs
-from collections.abc import AsyncGenerator, Callable
-from dataclasses import replace
-from typing import Any, cast
-
-from google.genai.errors import APIError, ClientError
-from google.genai.types import (
-    AutomaticFunctionCallingConfig,
-    Content,
-    FunctionDeclaration,
-    GenerateContentConfig,
-    GenerateContentResponse,
-    GoogleSearch,
-    HarmCategory,
-    Part,
-    SafetySetting,
-    Schema,
-    Tool,
-)
-from voluptuous_openapi import convert
-
-from homeassistant.components import conversation
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import device_registry as dr, llm
-from homeassistant.helpers.entity import Entity
-
-from .const import (
-    CONF_CHAT_MODEL,
-    CONF_DANGEROUS_BLOCK_THRESHOLD,
-    CONF_HARASSMENT_BLOCK_THRESHOLD,
-    CONF_HATE_BLOCK_THRESHOLD,
-    CONF_MAX_TOKENS,
-    CONF_SEXUAL_BLOCK_THRESHOLD,
-    CONF_TEMPERATURE,
-    CONF_TOP_K,
-    CONF_TOP_P,
-    CONF_USE_GOOGLE_SEARCH_TOOL,
-    DOMAIN,
-    LOGGER,
-    RECOMMENDED_CHAT_MODEL,
-    RECOMMENDED_HARM_BLOCK_THRESHOLD,
-    RECOMMENDED_MAX_TOKENS,
-    RECOMMENDED_TEMPERATURE,
-    RECOMMENDED_TOP_K,
-    RECOMMENDED_TOP_P,
-)
-
-# Max number of back and forth with the LLM to generate a response
-MAX_TOOL_ITERATIONS = 10
-
-ERROR_GETTING_RESPONSE = (
-    "Sorry, I had a problem getting a response from Google Generative AI."
-)
-
-
-SUPPORTED_SCHEMA_KEYS = {
-    # Gemini API does not support all of the OpenAPI schema
-    # SoT: https://ai.google.dev/api/caching#Schema
-    "type",
-    "format",
-    "description",
-    "nullable",
-    "enum",
-    "max_items",
-    "min_items",
-    "properties",
-    "required",
-    "items",
-}
-
-
-def _camel_to_snake(name: str) -> str:
-    """Convert camel case to snake case."""
-    return "".join(["_" + c.lower() if c.isupper() else c for c in name]).lstrip("_")
-
-
-def _format_schema(schema: dict[str, Any]) -> Schema:
-    """Format the schema to be compatible with Gemini API."""
-    if subschemas := schema.get("allOf"):
-        for subschema in subschemas:  # Gemini API does not support allOf keys
-            if "type" in subschema:  # Fallback to first subschema with 'type' field
-                return _format_schema(subschema)
-        return _format_schema(
-            subschemas[0]
-        )  # Or, if not found, to any of the subschemas
-
-    result = {}
-    for key, val in schema.items():
-        key = _camel_to_snake(key)
-        if key not in SUPPORTED_SCHEMA_KEYS:
-            continue
-        if key == "type":
-            val = val.upper()
-        elif key == "format":
-            # Gemini API does not support all formats, see: https://ai.google.dev/api/caching#Schema
-            # formats that are not supported are ignored
-            if schema.get("type") == "string" and val not in ("enum", "date-time"):
-                continue
-            if schema.get("type") == "number" and val not in ("float", "double"):
-                continue
-            if schema.get("type") == "integer" and val not in ("int32", "int64"):
-                continue
-            if schema.get("type") not in ("string", "number", "integer"):
-                continue
-        elif key == "items":
-            val = _format_schema(val)
-        elif key == "properties":
-            val = {k: _format_schema(v) for k, v in val.items()}
-        result[key] = val
-
-    if result.get("enum") and result.get("type") != "STRING":
-        # enum is only allowed for STRING type. This is safe as long as the schema
-        # contains vol.Coerce for the respective type, for example:
-        # vol.All(vol.Coerce(int), vol.In([1, 2, 3]))
-        result["type"] = "STRING"
-        result["enum"] = [str(item) for item in result["enum"]]
-
-    if result.get("type") == "OBJECT" and not result.get("properties"):
-        # An object with undefined properties is not supported by Gemini API.
-        # Fallback to JSON string. This will probably fail for most tools that want it,
-        # but we don't have a better fallback strategy so far.
-        result["properties"] = {"json": {"type": "STRING"}}
-        result["required"] = []
-    return cast(Schema, result)
-
-
-def _format_tool(
-    tool: llm.Tool, custom_serializer: Callable[[Any], Any] | None
-) -> Tool:
-    """Format tool specification."""
-
-    if tool.parameters.schema:
-        parameters = _format_schema(
-            convert(tool.parameters, custom_serializer=custom_serializer)
-        )
-    else:
-        parameters = None
-
-    return Tool(
-        function_declarations=[
-            FunctionDeclaration(
-                name=tool.name,
-                description=tool.description,
-                parameters=parameters,
-            )
-        ]
-    )
-
-
-def _escape_decode(value: Any) -> Any:
-    """Recursively call codecs.escape_decode on all values."""
-    if isinstance(value, str):
-        return codecs.escape_decode(bytes(value, "utf-8"))[0].decode("utf-8")  # type: ignore[attr-defined]
-    if isinstance(value, list):
-        return [_escape_decode(item) for item in value]
-    if isinstance(value, dict):
-        return {k: _escape_decode(v) for k, v in value.items()}
-    return value
-
-
-def _create_google_tool_response_parts(
-    parts: list[conversation.ToolResultContent],
-) -> list[Part]:
-    """Create Google tool response parts."""
-    return [
-        Part.from_function_response(
-            name=tool_result.tool_name, response=tool_result.tool_result
-        )
-        for tool_result in parts
-    ]
-
-
-def _create_google_tool_response_content(
-    content: list[conversation.ToolResultContent],
-) -> Content:
-    """Create a Google tool response content."""
-    return Content(
-        role="user",
-        parts=_create_google_tool_response_parts(content),
-    )
-
-
-def _convert_content(
-    content: (
-        conversation.UserContent
-        | conversation.AssistantContent
-        | conversation.SystemContent
-    ),
-) -> Content:
-    """Convert HA content to Google content."""
-    if content.role != "assistant" or not content.tool_calls:
-        role = "model" if content.role == "assistant" else content.role
-        return Content(
-            role=role,
-            parts=[
-                Part.from_text(text=content.content if content.content else ""),
-            ],
-        )
-
-    # Handle the Assistant content with tool calls.
-    assert type(content) is conversation.AssistantContent
-    parts: list[Part] = []
-
-    if content.content:
-        parts.append(Part.from_text(text=content.content))
-
-    if content.tool_calls:
-        parts.extend(
-            [
-                Part.from_function_call(
-                    name=tool_call.tool_name,
-                    args=_escape_decode(tool_call.tool_args),
-                )
-                for tool_call in content.tool_calls
-            ]
-        )
-
-    return Content(role="model", parts=parts)
-
-
-async def _transform_stream(
-    result: AsyncGenerator[GenerateContentResponse],
-) -> AsyncGenerator[conversation.AssistantContentDeltaDict]:
-    new_message = True
-    try:
-        async for response in result:
-            LOGGER.debug("Received response chunk: %s", response)
-            chunk: conversation.AssistantContentDeltaDict = {}
-
-            if new_message:
-                chunk["role"] = "assistant"
-                new_message = False
-
-            # According to the API docs, this would mean no candidate is returned, so we can safely throw an error here.
-            if response.prompt_feedback or not response.candidates:
-                reason = (
-                    response.prompt_feedback.block_reason_message
-                    if response.prompt_feedback
-                    else "unknown"
-                )
-                raise HomeAssistantError(
-                    f"The message got blocked due to content violations, reason: {reason}"
-                )
-
-            candidate = response.candidates[0]
-
-            if (
-                candidate.finish_reason is not None
-                and candidate.finish_reason != "STOP"
-            ):
-                # The message ended due to a content error as explained in: https://ai.google.dev/api/generate-content#FinishReason
-                LOGGER.error(
-                    "Error in Google Generative AI response: %s, see: https://ai.google.dev/api/generate-content#FinishReason",
-                    candidate.finish_reason,
-                )
-                raise HomeAssistantError(
-                    f"{ERROR_GETTING_RESPONSE} Reason: {candidate.finish_reason}"
-                )
-
-            response_parts = (
-                candidate.content.parts
-                if candidate.content is not None and candidate.content.parts is not None
-                else []
-            )
-
-            content = "".join([part.text for part in response_parts if part.text])
-            tool_calls = []
-            for part in response_parts:
-                if not part.function_call:
-                    continue
-                tool_call = part.function_call
-                tool_name = tool_call.name if tool_call.name else ""
-                tool_args = _escape_decode(tool_call.args)
-                tool_calls.append(
-                    llm.ToolInput(tool_name=tool_name, tool_args=tool_args)
-                )
-
-            if tool_calls:
-                chunk["tool_calls"] = tool_calls
-
-            chunk["content"] = content
-            yield chunk
-    except (
-        APIError,
-        ValueError,
-    ) as err:
-        LOGGER.error("Error sending message: %s %s", type(err), err)
-        if isinstance(err, APIError):
-            message = err.message
-        else:
-            message = type(err).__name__
-        error = f"{ERROR_GETTING_RESPONSE}: {message}"
-        raise HomeAssistantError(error) from err
-
-
-class GoogleGenerativeAILLMBaseEntity(Entity):
-    """Google Generative AI base entity."""
-
-    _attr_has_entity_name = True
-    _attr_name = None
-
-    def __init__(self, entry: ConfigEntry) -> None:
-        """Initialize the agent."""
-        self.entry = entry
-        self._genai_client = entry.runtime_data
-        self._attr_unique_id = entry.entry_id
-        self._attr_device_info = dr.DeviceInfo(
-            identifiers={(DOMAIN, entry.entry_id)},
-            name=entry.title,
-            manufacturer="Google",
-            model="Generative AI",
-            entry_type=dr.DeviceEntryType.SERVICE,
-        )
-
-    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[Tool | Callable[..., Any]] | None = None
-        if chat_log.llm_api:
-            tools = [
-                _format_tool(tool, chat_log.llm_api.custom_serializer)
-                for tool in chat_log.llm_api.tools
-            ]
-
-        # Using search grounding allows the model to retrieve information from the web,
-        # however, it may interfere with how the model decides to use some tools, or entities
-        # for example weather entity may be disregarded if the model chooses to Google it.
-        if options.get(CONF_USE_GOOGLE_SEARCH_TOOL) is True:
-            tools = tools or []
-            tools.append(Tool(google_search=GoogleSearch()))
-
-        model_name = self.entry.options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL)
-        # Avoid INVALID_ARGUMENT Developer instruction is not enabled for <model>
-        supports_system_instruction = (
-            "gemma" not in model_name
-            and "gemini-2.0-flash-preview-image-generation" not in model_name
-        )
-
-        prompt_content = cast(
-            conversation.SystemContent,
-            chat_log.content[0],
-        )
-
-        if prompt_content.content:
-            prompt = prompt_content.content
-        else:
-            raise HomeAssistantError("Invalid prompt content")
-
-        messages: list[Content] = []
-
-        # Google groups tool results, we do not. Group them before sending.
-        tool_results: list[conversation.ToolResultContent] = []
-
-        for chat_content in chat_log.content[1:-1]:
-            if chat_content.role == "tool_result":
-                tool_results.append(chat_content)
-                continue
-
-            if (
-                not isinstance(chat_content, conversation.ToolResultContent)
-                and chat_content.content == ""
-            ):
-                # Skipping is not possible since the number of function calls need to match the number of function responses
-                # and skipping one would mean removing the other and hence this would prevent a proper chat log
-                chat_content = replace(chat_content, content=" ")
-
-            if tool_results:
-                messages.append(_create_google_tool_response_content(tool_results))
-                tool_results.clear()
-
-            messages.append(_convert_content(chat_content))
-
-        # The SDK requires the first message to be a user message
-        # This is not the case if user used `start_conversation`
-        # Workaround from https://github.com/googleapis/python-genai/issues/529#issuecomment-2740964537
-        if messages and messages[0].role != "user":
-            messages.insert(
-                0,
-                Content(role="user", parts=[Part.from_text(text=" ")]),
-            )
-
-        if tool_results:
-            messages.append(_create_google_tool_response_content(tool_results))
-        generateContentConfig = GenerateContentConfig(
-            temperature=self.entry.options.get(
-                CONF_TEMPERATURE, RECOMMENDED_TEMPERATURE
-            ),
-            top_k=self.entry.options.get(CONF_TOP_K, RECOMMENDED_TOP_K),
-            top_p=self.entry.options.get(CONF_TOP_P, RECOMMENDED_TOP_P),
-            max_output_tokens=self.entry.options.get(
-                CONF_MAX_TOKENS, RECOMMENDED_MAX_TOKENS
-            ),
-            safety_settings=[
-                SafetySetting(
-                    category=HarmCategory.HARM_CATEGORY_HATE_SPEECH,
-                    threshold=self.entry.options.get(
-                        CONF_HATE_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
-                    ),
-                ),
-                SafetySetting(
-                    category=HarmCategory.HARM_CATEGORY_HARASSMENT,
-                    threshold=self.entry.options.get(
-                        CONF_HARASSMENT_BLOCK_THRESHOLD,
-                        RECOMMENDED_HARM_BLOCK_THRESHOLD,
-                    ),
-                ),
-                SafetySetting(
-                    category=HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
-                    threshold=self.entry.options.get(
-                        CONF_DANGEROUS_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
-                    ),
-                ),
-                SafetySetting(
-                    category=HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
-                    threshold=self.entry.options.get(
-                        CONF_SEXUAL_BLOCK_THRESHOLD, RECOMMENDED_HARM_BLOCK_THRESHOLD
-                    ),
-                ),
-            ],
-            tools=tools or None,
-            system_instruction=prompt if supports_system_instruction else None,
-            automatic_function_calling=AutomaticFunctionCallingConfig(
-                disable=True, maximum_remote_calls=None
-            ),
-        )
-
-        if not supports_system_instruction:
-            messages = [
-                Content(role="user", parts=[Part.from_text(text=prompt)]),
-                Content(role="model", parts=[Part.from_text(text="Ok")]),
-                *messages,
-            ]
-        chat = self._genai_client.aio.chats.create(
-            model=model_name, history=messages, config=generateContentConfig
-        )
-        user_message = chat_log.content[-1]
-        assert isinstance(user_message, conversation.UserContent)
-        chat_request: str | list[Part] = user_message.content
-        # To prevent infinite loops, we limit the number of iterations
-        for _iteration in range(MAX_TOOL_ITERATIONS):
-            try:
-                chat_response_generator = await chat.send_message_stream(
-                    message=chat_request
-                )
-            except (
-                APIError,
-                ClientError,
-                ValueError,
-            ) as err:
-                LOGGER.error("Error sending message: %s %s", type(err), err)
-                error = ERROR_GETTING_RESPONSE
-                raise HomeAssistantError(error) from err
-
-            chat_request = _create_google_tool_response_parts(
-                [
-                    content
-                    async for content in chat_log.async_add_delta_content_stream(
-                        self.entity_id,
-                        _transform_stream(chat_response_generator),
-                    )
-                    if isinstance(content, conversation.ToolResultContent)
-                ]
-            )
-
-            if not chat_log.unresponded_tool_results:
-                break

homeassistant/components/google_generative_ai_conversation/tts.py

@@ -1,216 +0,0 @@
-"""Text to speech support for Google Generative AI."""
-
-from __future__ import annotations
-
-from contextlib import suppress
-import io
-import logging
-from typing import Any
-import wave
-
-from google.genai import types
-
-from homeassistant.components.tts import (
-    ATTR_VOICE,
-    TextToSpeechEntity,
-    TtsAudioType,
-    Voice,
-)
-from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant, callback
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
-
-from .const import ATTR_MODEL, DOMAIN, RECOMMENDED_TTS_MODEL
-
-_LOGGER = logging.getLogger(__name__)
-
-
-async def async_setup_entry(
-    hass: HomeAssistant,
-    config_entry: ConfigEntry,
-    async_add_entities: AddConfigEntryEntitiesCallback,
-) -> None:
-    """Set up TTS entity."""
-    tts_entity = GoogleGenerativeAITextToSpeechEntity(config_entry)
-    async_add_entities([tts_entity])
-
-
-class GoogleGenerativeAITextToSpeechEntity(TextToSpeechEntity):
-    """Google Generative AI text-to-speech entity."""
-
-    _attr_supported_options = [ATTR_VOICE, ATTR_MODEL]
-    # See https://ai.google.dev/gemini-api/docs/speech-generation#languages
-    _attr_supported_languages = [
-        "ar-EG",
-        "bn-BD",
-        "de-DE",
-        "en-IN",
-        "en-US",
-        "es-US",
-        "fr-FR",
-        "hi-IN",
-        "id-ID",
-        "it-IT",
-        "ja-JP",
-        "ko-KR",
-        "mr-IN",
-        "nl-NL",
-        "pl-PL",
-        "pt-BR",
-        "ro-RO",
-        "ru-RU",
-        "ta-IN",
-        "te-IN",
-        "th-TH",
-        "tr-TR",
-        "uk-UA",
-        "vi-VN",
-    ]
-    _attr_default_language = "en-US"
-    # See https://ai.google.dev/gemini-api/docs/speech-generation#voices
-    _supported_voices = [
-        Voice(voice.split(" ", 1)[0].lower(), voice)
-        for voice in (
-            "Zephyr (Bright)",
-            "Puck (Upbeat)",
-            "Charon (Informative)",
-            "Kore (Firm)",
-            "Fenrir (Excitable)",
-            "Leda (Youthful)",
-            "Orus (Firm)",
-            "Aoede (Breezy)",
-            "Callirrhoe (Easy-going)",
-            "Autonoe (Bright)",
-            "Enceladus (Breathy)",
-            "Iapetus (Clear)",
-            "Umbriel (Easy-going)",
-            "Algieba (Smooth)",
-            "Despina (Smooth)",
-            "Erinome (Clear)",
-            "Algenib (Gravelly)",
-            "Rasalgethi (Informative)",
-            "Laomedeia (Upbeat)",
-            "Achernar (Soft)",
-            "Alnilam (Firm)",
-            "Schedar (Even)",
-            "Gacrux (Mature)",
-            "Pulcherrima (Forward)",
-            "Achird (Friendly)",
-            "Zubenelgenubi (Casual)",
-            "Vindemiatrix (Gentle)",
-            "Sadachbia (Lively)",
-            "Sadaltager (Knowledgeable)",
-            "Sulafat (Warm)",
-        )
-    ]
-
-    def __init__(self, entry: ConfigEntry) -> None:
-        """Initialize Google Generative AI Conversation speech entity."""
-        self.entry = entry
-        self._attr_name = "Google Generative AI TTS"
-        self._attr_unique_id = f"{entry.entry_id}_tts"
-        self._attr_device_info = dr.DeviceInfo(
-            identifiers={(DOMAIN, entry.entry_id)},
-            name=entry.title,
-            manufacturer="Google",
-            model="Generative AI",
-            entry_type=dr.DeviceEntryType.SERVICE,
-        )
-        self._genai_client = entry.runtime_data
-        self._default_voice_id = self._supported_voices[0].voice_id
-
-    @callback
-    def async_get_supported_voices(self, language: str) -> list[Voice] | None:
-        """Return a list of supported voices for a language."""
-        return self._supported_voices
-
-    async def async_get_tts_audio(
-        self, message: str, language: str, options: dict[str, Any]
-    ) -> TtsAudioType:
-        """Load tts audio file from the engine."""
-        try:
-            response = self._genai_client.models.generate_content(
-                model=options.get(ATTR_MODEL, RECOMMENDED_TTS_MODEL),
-                contents=message,
-                config=types.GenerateContentConfig(
-                    response_modalities=["AUDIO"],
-                    speech_config=types.SpeechConfig(
-                        voice_config=types.VoiceConfig(
-                            prebuilt_voice_config=types.PrebuiltVoiceConfig(
-                                voice_name=options.get(
-                                    ATTR_VOICE, self._default_voice_id
-                                )
-                            )
-                        )
-                    ),
-                ),
-            )
-
-            data = response.candidates[0].content.parts[0].inline_data.data
-            mime_type = response.candidates[0].content.parts[0].inline_data.mime_type
-        except Exception as exc:
-            _LOGGER.warning(
-                "Error during processing of TTS request %s", exc, exc_info=True
-            )
-            raise HomeAssistantError(exc) from exc
-        return "wav", self._convert_to_wav(data, mime_type)
-
-    def _convert_to_wav(self, audio_data: bytes, mime_type: str) -> bytes:
-        """Generate a WAV file header for the given audio data and parameters.
-
-        Args:
-            audio_data: The raw audio data as a bytes object.
-            mime_type: Mime type of the audio data.
-
-        Returns:
-            A bytes object representing the WAV file header.
-
-        """
-        parameters = self._parse_audio_mime_type(mime_type)
-
-        wav_buffer = io.BytesIO()
-        with wave.open(wav_buffer, "wb") as wf:
-            wf.setnchannels(1)
-            wf.setsampwidth(parameters["bits_per_sample"] // 8)
-            wf.setframerate(parameters["rate"])
-            wf.writeframes(audio_data)
-
-        return wav_buffer.getvalue()
-
-    def _parse_audio_mime_type(self, mime_type: str) -> dict[str, int]:
-        """Parse bits per sample and rate from an audio MIME type string.
-
-        Assumes bits per sample is encoded like "L16" and rate as "rate=xxxxx".
-
-        Args:
-            mime_type: The audio MIME type string (e.g., "audio/L16;rate=24000").
-
-        Returns:
-            A dictionary with "bits_per_sample" and "rate" keys. Values will be
-            integers if found, otherwise None.
-
-        """
-        if not mime_type.startswith("audio/L"):
-            _LOGGER.warning("Received unexpected MIME type %s", mime_type)
-            raise HomeAssistantError(f"Unsupported audio MIME type: {mime_type}")
-
-        bits_per_sample = 16
-        rate = 24000
-
-        # Extract rate from parameters
-        parts = mime_type.split(";")
-        for param in parts:  # Skip the main type part
-            param = param.strip()
-            if param.lower().startswith("rate="):
-                # Handle cases like "rate=" with no value or non-integer value and keep rate as default
-                with suppress(ValueError, IndexError):
-                    rate_str = param.split("=", 1)[1]
-                    rate = int(rate_str)
-            elif param.startswith("audio/L"):
-                # Keep bits_per_sample as default if conversion fails
-                with suppress(ValueError, IndexError):
-                    bits_per_sample = int(param.split("L", 1)[1])
-
-        return {"bits_per_sample": bits_per_sample, "rate": rate}

homeassistant/components/google_photos/services.py

@@ -16,7 +16,6 @@ from homeassistant.core import (
     ServiceCall,
     ServiceResponse,
     SupportsResponse,
-    callback,
 )
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers import config_validation as cv
@@ -78,85 +77,85 @@ def _read_file_contents(
     return results
 
 
-async def _async_handle_upload(call: ServiceCall) -> ServiceResponse:
-    """Generate content from text and optionally images."""
-    config_entry: GooglePhotosConfigEntry | None = (
-        call.hass.config_entries.async_get_entry(call.data[CONF_CONFIG_ENTRY_ID])
-    )
-    if not config_entry:
-        raise ServiceValidationError(
-            translation_domain=DOMAIN,
-            translation_key="integration_not_found",
-            translation_placeholders={"target": DOMAIN},
-        )
-    scopes = config_entry.data["token"]["scope"].split(" ")
-    if UPLOAD_SCOPE not in scopes:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="missing_upload_permission",
-            translation_placeholders={"target": DOMAIN},
-        )
-    coordinator = config_entry.runtime_data
-    client_api = coordinator.client
-    upload_tasks = []
-    file_results = await call.hass.async_add_executor_job(
-        _read_file_contents, call.hass, call.data[CONF_FILENAME]
-    )
-
-    album = call.data[CONF_ALBUM]
-    try:
-        album_id = await coordinator.get_or_create_album(album)
-    except GooglePhotosApiError as err:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="create_album_error",
-            translation_placeholders={"message": str(err)},
-        ) from err
-
-    for mime_type, content in file_results:
-        upload_tasks.append(client_api.upload_content(content, mime_type))
-    try:
-        upload_results = await asyncio.gather(*upload_tasks)
-    except GooglePhotosApiError as err:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="upload_error",
-            translation_placeholders={"message": str(err)},
-        ) from err
-    try:
-        upload_result = await client_api.create_media_items(
-            [
-                NewMediaItem(SimpleMediaItem(upload_token=upload_result.upload_token))
-                for upload_result in upload_results
-            ],
-            album_id=album_id,
-        )
-    except GooglePhotosApiError as err:
-        raise HomeAssistantError(
-            translation_domain=DOMAIN,
-            translation_key="api_error",
-            translation_placeholders={"message": str(err)},
-        ) from err
-    if call.return_response:
-        return {
-            "media_items": [
-                {"media_item_id": item_result.media_item.id}
-                for item_result in upload_result.new_media_item_results
-                if item_result.media_item and item_result.media_item.id
-            ],
-            "album_id": album_id,
-        }
-    return None
-
-
-@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Register Google Photos services."""
 
+    async def async_handle_upload(call: ServiceCall) -> ServiceResponse:
+        """Generate content from text and optionally images."""
+        config_entry: GooglePhotosConfigEntry | None = (
+            hass.config_entries.async_get_entry(call.data[CONF_CONFIG_ENTRY_ID])
+        )
+        if not config_entry:
+            raise ServiceValidationError(
+                translation_domain=DOMAIN,
+                translation_key="integration_not_found",
+                translation_placeholders={"target": DOMAIN},
+            )
+        scopes = config_entry.data["token"]["scope"].split(" ")
+        if UPLOAD_SCOPE not in scopes:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="missing_upload_permission",
+                translation_placeholders={"target": DOMAIN},
+            )
+        coordinator = config_entry.runtime_data
+        client_api = coordinator.client
+        upload_tasks = []
+        file_results = await hass.async_add_executor_job(
+            _read_file_contents, hass, call.data[CONF_FILENAME]
+        )
+
+        album = call.data[CONF_ALBUM]
+        try:
+            album_id = await coordinator.get_or_create_album(album)
+        except GooglePhotosApiError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="create_album_error",
+                translation_placeholders={"message": str(err)},
+            ) from err
+
+        for mime_type, content in file_results:
+            upload_tasks.append(client_api.upload_content(content, mime_type))
+        try:
+            upload_results = await asyncio.gather(*upload_tasks)
+        except GooglePhotosApiError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="upload_error",
+                translation_placeholders={"message": str(err)},
+            ) from err
+        try:
+            upload_result = await client_api.create_media_items(
+                [
+                    NewMediaItem(
+                        SimpleMediaItem(upload_token=upload_result.upload_token)
+                    )
+                    for upload_result in upload_results
+                ],
+                album_id=album_id,
+            )
+        except GooglePhotosApiError as err:
+            raise HomeAssistantError(
+                translation_domain=DOMAIN,
+                translation_key="api_error",
+                translation_placeholders={"message": str(err)},
+            ) from err
+        if call.return_response:
+            return {
+                "media_items": [
+                    {"media_item_id": item_result.media_item.id}
+                    for item_result in upload_result.new_media_item_results
+                    if item_result.media_item and item_result.media_item.id
+                ],
+                "album_id": album_id,
+            }
+        return None
+
     hass.services.async_register(
         DOMAIN,
         UPLOAD_SERVICE,
-        _async_handle_upload,
+        async_handle_upload,
         schema=UPLOAD_SERVICE_SCHEMA,
         supports_response=SupportsResponse.OPTIONAL,
     )

homeassistant/components/google_sheets/services.py

@@ -13,7 +13,7 @@ from gspread.utils import ValueInputOption
 import voluptuous as vol
 
 from homeassistant.const import CONF_ACCESS_TOKEN, CONF_TOKEN
-from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.selector import ConfigEntrySelector
@@ -76,7 +76,6 @@ async def _async_append_to_sheet(call: ServiceCall) -> None:
     await call.hass.async_add_executor_job(_append_to_sheet, call, entry)
 
 
-@callback
 def async_setup_services(hass: HomeAssistant) -> None:
     """Add the services for Google Sheets."""
 

homeassistant/components/hassio/update_helper.py

@@ -29,7 +29,8 @@ async def update_addon(
     client = get_supervisor_client(hass)
 
     if backup:
-        from .backup import backup_addon_before_update  # noqa: PLC0415
+        # pylint: disable-next=import-outside-toplevel
+        from .backup import backup_addon_before_update
 
         await backup_addon_before_update(hass, addon, addon_name, installed_version)
 
@@ -49,7 +50,8 @@ async def update_core(hass: HomeAssistant, version: str | None, backup: bool) ->
     client = get_supervisor_client(hass)
 
     if backup:
-        from .backup import backup_core_before_update  # noqa: PLC0415
+        # pylint: disable-next=import-outside-toplevel
+        from .backup import backup_core_before_update
 
         await backup_core_before_update(hass)
 
@@ -69,7 +71,8 @@ async def update_os(hass: HomeAssistant, version: str | None, backup: bool) -> N
     client = get_supervisor_client(hass)
 
     if backup:
-        from .backup import backup_core_before_update  # noqa: PLC0415
+        # pylint: disable-next=import-outside-toplevel
+        from .backup import backup_core_before_update
 
         await backup_core_before_update(hass)
 

homeassistant/components/here_travel_time/coordinator.py

@@ -100,11 +100,9 @@ class HERERoutingDataUpdateCoordinator(DataUpdateCoordinator[HERETravelTimeData]
         try:
             response = await self._api.route(
                 transport_mode=TransportMode(params.travel_mode),
-                origin=here_routing.Place(
-                    float(params.origin[0]), float(params.origin[1])
-                ),
+                origin=here_routing.Place(params.origin[0], params.origin[1]),
                 destination=here_routing.Place(
-                    float(params.destination[0]), float(params.destination[1])
+                    params.destination[0], params.destination[1]
                 ),
                 routing_mode=params.route_mode,
                 arrival_time=params.arrival,
@@ -135,8 +133,8 @@ class HERERoutingDataUpdateCoordinator(DataUpdateCoordinator[HERETravelTimeData]
     def _parse_routing_response(self, response: dict[str, Any]) -> HERETravelTimeData:
         """Parse the routing response dict to a HERETravelTimeData."""
         distance: float = 0.0
-        duration: int = 0
-        duration_in_traffic: int = 0
+        duration: float = 0.0
+        duration_in_traffic: float = 0.0
 
         for section in response["routes"][0]["sections"]:
             distance += DistanceConverter.convert(
@@ -169,8 +167,8 @@ class HERERoutingDataUpdateCoordinator(DataUpdateCoordinator[HERETravelTimeData]
             destination_name = names[0]["value"]
         return HERETravelTimeData(
             attribution=None,
-            duration=duration,
-            duration_in_traffic=duration_in_traffic,
+            duration=round(duration / 60),
+            duration_in_traffic=round(duration_in_traffic / 60),
             distance=distance,
             origin=f"{mapped_origin_lat},{mapped_origin_lon}",
             destination=f"{mapped_destination_lat},{mapped_destination_lon}",
@@ -273,13 +271,13 @@ class HERETransitDataUpdateCoordinator(
             UnitOfLength.METERS,
             UnitOfLength.KILOMETERS,
         )
-        duration: int = sum(
+        duration: float = sum(
             section["travelSummary"]["duration"] for section in sections
         )
         return HERETravelTimeData(
             attribution=attribution,
-            duration=duration,
-            duration_in_traffic=duration,
+            duration=round(duration / 60),
+            duration_in_traffic=round(duration / 60),
             distance=distance,
             origin=f"{mapped_origin_lat},{mapped_origin_lon}",
             destination=f"{mapped_destination_lat},{mapped_destination_lon}",

homeassistant/components/here_travel_time/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/here_travel_time",
   "iot_class": "cloud_polling",
   "loggers": ["here_routing", "here_transit", "homeassistant.helpers.location"],
-  "requirements": ["here-routing==1.2.0", "here-transit==1.2.1"]
+  "requirements": ["here-routing==1.0.1", "here-transit==1.2.1"]
 }

homeassistant/components/here_travel_time/model.py

@@ -6,8 +6,6 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import TypedDict
 
-from here_routing import RoutingMode
-
 
 class HERETravelTimeData(TypedDict):
     """Routing information."""
@@ -29,6 +27,6 @@ class HERETravelTimeAPIParams:
     destination: list[str]
     origin: list[str]
     travel_mode: str
-    route_mode: RoutingMode
+    route_mode: str
     arrival: datetime | None
     departure: datetime | None

homeassistant/components/here_travel_time/sensor.py

@@ -55,18 +55,14 @@ def sensor_descriptions(travel_mode: str) -> tuple[SensorEntityDescription, ...]
             icon=ICONS.get(travel_mode, ICON_CAR),
             key=ATTR_DURATION,
             state_class=SensorStateClass.MEASUREMENT,
-            device_class=SensorDeviceClass.DURATION,
-            native_unit_of_measurement=UnitOfTime.SECONDS,
-            suggested_unit_of_measurement=UnitOfTime.MINUTES,
+            native_unit_of_measurement=UnitOfTime.MINUTES,
         ),
         SensorEntityDescription(
             translation_key="duration_in_traffic",
             icon=ICONS.get(travel_mode, ICON_CAR),
             key=ATTR_DURATION_IN_TRAFFIC,
             state_class=SensorStateClass.MEASUREMENT,
-            device_class=SensorDeviceClass.DURATION,
-            native_unit_of_measurement=UnitOfTime.SECONDS,
-            suggested_unit_of_measurement=UnitOfTime.MINUTES,
+            native_unit_of_measurement=UnitOfTime.MINUTES,
         ),
         SensorEntityDescription(
             translation_key="distance",

homeassistant/components/holiday/manifest.json

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

homeassistant/components/home_connect/manifest.json

@@ -21,7 +21,6 @@
   "documentation": "https://www.home-assistant.io/integrations/home_connect",
   "iot_class": "cloud_push",
   "loggers": ["aiohomeconnect"],
-  "quality_scale": "platinum",
-  "requirements": ["aiohomeconnect==0.18.1"],
+  "requirements": ["aiohomeconnect==0.17.1"],
   "zeroconf": ["_homeconnect._tcp.local."]
 }