homeassistant-stubs 2025.1.4__py3-none-any.whl → 2025.2.0__py3-none-any.whl

homeassistant-stubs/components/backup/__init__.pyi

@@ -1,5 +1,10 @@
 from .agent import BackupAgent as BackupAgent, BackupAgentError as BackupAgentError, BackupAgentPlatformProtocol as BackupAgentPlatformProtocol, LocalBackupAgent as LocalBackupAgent
-from .manager import BackupPlatformProtocol as BackupPlatformProtocol, BackupReaderWriter as BackupReaderWriter, BackupReaderWriterError as BackupReaderWriterError, CreateBackupEvent as CreateBackupEvent, IncorrectPasswordError as IncorrectPasswordError, ManagerBackup as ManagerBackup, NewBackup as NewBackup, WrittenBackup as WrittenBackup
-from .models import AddonInfo as AddonInfo, AgentBackup as AgentBackup, Folder as Folder
+from .manager import BackupManager, BackupManagerError as BackupManagerError, BackupPlatformProtocol as BackupPlatformProtocol, BackupReaderWriter as BackupReaderWriter, BackupReaderWriterError as BackupReaderWriterError, CreateBackupEvent as CreateBackupEvent, CreateBackupStage as CreateBackupStage, CreateBackupState as CreateBackupState, IdleEvent as IdleEvent, IncorrectPasswordError as IncorrectPasswordError, ManagerBackup as ManagerBackup, NewBackup as NewBackup, RestoreBackupEvent as RestoreBackupEvent, RestoreBackupStage as RestoreBackupStage, RestoreBackupState as RestoreBackupState, WrittenBackup as WrittenBackup
+from .models import AddonInfo as AddonInfo, AgentBackup as AgentBackup, BackupNotFound as BackupNotFound, Folder as Folder
+from .util import suggested_filename as suggested_filename, suggested_filename_from_name_date as suggested_filename_from_name_date
+from homeassistant.core import HomeAssistant, callback
 
-__all__ = ['AddonInfo', 'AgentBackup', 'ManagerBackup', 'BackupAgent', 'BackupAgentError', 'BackupAgentPlatformProtocol', 'BackupPlatformProtocol', 'BackupReaderWriter', 'BackupReaderWriterError', 'CreateBackupEvent', 'Folder', 'IncorrectPasswordError', 'LocalBackupAgent', 'NewBackup', 'WrittenBackup']
+__all__ = ['AddonInfo', 'AgentBackup', 'BackupAgent', 'BackupAgentError', 'BackupAgentPlatformProtocol', 'BackupManagerError', 'BackupNotFound', 'BackupPlatformProtocol', 'BackupReaderWriter', 'BackupReaderWriterError', 'CreateBackupEvent', 'CreateBackupStage', 'CreateBackupState', 'Folder', 'IdleEvent', 'IncorrectPasswordError', 'LocalBackupAgent', 'ManagerBackup', 'NewBackup', 'RestoreBackupEvent', 'RestoreBackupStage', 'RestoreBackupState', 'WrittenBackup', 'async_get_manager', 'suggested_filename', 'suggested_filename_from_name_date']
+
+@callback
+def async_get_manager(hass: HomeAssistant) -> BackupManager: ...

homeassistant-stubs/components/backup/agent.pyi

@@ -1,20 +1,19 @@
 import abc
-from .models import AgentBackup as AgentBackup
+from .models import AgentBackup as AgentBackup, BackupAgentError as BackupAgentError
 from collections.abc import AsyncIterator, Callable as Callable, Coroutine
 from homeassistant.core import HomeAssistant as HomeAssistant, callback as callback
-from homeassistant.exceptions import HomeAssistantError as HomeAssistantError
 from pathlib import Path
-from propcache import cached_property
+from propcache.api import cached_property
 from typing import Any, Protocol
 
-class BackupAgentError(HomeAssistantError): ...
-
 class BackupAgentUnreachableError(BackupAgentError):
+    error_code: str
     _message: str
 
 class BackupAgent(abc.ABC, metaclass=abc.ABCMeta):
     domain: str
     name: str
+    unique_id: str
     @cached_property
     def agent_id(self) -> str: ...
     @abc.abstractmethod
@@ -31,6 +30,8 @@ class BackupAgent(abc.ABC, metaclass=abc.ABCMeta):
 class LocalBackupAgent(BackupAgent, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def get_backup_path(self, backup_id: str) -> Path: ...
+    @abc.abstractmethod
+    def get_new_backup_path(self, backup: AgentBackup) -> Path: ...
 
 class BackupAgentPlatformProtocol(Protocol):
     async def async_get_backup_agents(self, hass: HomeAssistant, **kwargs: Any) -> list[BackupAgent]: ...

homeassistant-stubs/components/backup/backup.pyi

@@ -1,7 +1,7 @@
 from .agent import BackupAgent as BackupAgent, LocalBackupAgent as LocalBackupAgent
 from .const import DOMAIN as DOMAIN, LOGGER as LOGGER
-from .models import AgentBackup as AgentBackup
-from .util import read_backup as read_backup
+from .models import AgentBackup as AgentBackup, BackupNotFound as BackupNotFound
+from .util import read_backup as read_backup, suggested_filename as suggested_filename
 from _typeshed import Incomplete
 from collections.abc import AsyncIterator, Callable as Callable, Coroutine
 from homeassistant.core import HomeAssistant as HomeAssistant
@@ -14,16 +14,18 @@ async def async_get_backup_agents(hass: HomeAssistant, **kwargs: Any) -> list[Ba
 class CoreLocalBackupAgent(LocalBackupAgent):
     domain = DOMAIN
     name: str
+    unique_id: str
     _hass: Incomplete
     _backup_dir: Incomplete
-    _backups: dict[str, AgentBackup]
+    _backups: dict[str, tuple[AgentBackup, Path]]
     _loaded_backups: bool
     def __init__(self, hass: HomeAssistant) -> None: ...
     async def _load_backups(self) -> None: ...
-    def _read_backups(self) -> dict[str, AgentBackup]: ...
+    def _read_backups(self) -> dict[str, tuple[AgentBackup, Path]]: ...
     async def async_download_backup(self, backup_id: str, **kwargs: Any) -> AsyncIterator[bytes]: ...
     async def async_upload_backup(self, *, open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]], backup: AgentBackup, **kwargs: Any) -> None: ...
     async def async_list_backups(self, **kwargs: Any) -> list[AgentBackup]: ...
     async def async_get_backup(self, backup_id: str, **kwargs: Any) -> AgentBackup | None: ...
     def get_backup_path(self, backup_id: str) -> Path: ...
+    def get_new_backup_path(self, backup: AgentBackup) -> Path: ...
     async def async_delete_backup(self, backup_id: str, **kwargs: Any) -> None: ...

homeassistant-stubs/components/backup/config.pyi

@@ -1,8 +1,8 @@
+import datetime as dt
 from .const import LOGGER as LOGGER
 from .manager import BackupManager as BackupManager, ManagerBackup as ManagerBackup
 from .models import BackupManagerError as BackupManagerError, Folder as Folder
 from _typeshed import Incomplete
-from collections.abc import Callable as Callable
 from cronsim import CronSim
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -14,9 +14,11 @@ from typing import Self, TypedDict
 
 CRON_PATTERN_DAILY: str
 CRON_PATTERN_WEEKLY: str
+DEFAULT_BACKUP_TIME: Incomplete
 BACKUP_START_TIME_JITTER: Incomplete
 
 class StoredBackupConfig(TypedDict):
+    agents: dict[str, StoredAgentConfig]
     create_backup: StoredCreateBackupConfig
     last_attempted_automatic_backup: str | None
     last_completed_automatic_backup: str | None
@@ -25,6 +27,7 @@ class StoredBackupConfig(TypedDict):
 
 @dataclass(kw_only=True)
 class BackupConfigData:
+    agents: dict[str, AgentConfig]
     create_backup: CreateBackupConfig
     last_attempted_automatic_backup: datetime | None = ...
     last_completed_automatic_backup: datetime | None = ...
@@ -39,7 +42,18 @@ class BackupConfig:
     _manager: Incomplete
     def __init__(self, hass: HomeAssistant, manager: BackupManager) -> None: ...
     def load(self, stored_config: StoredBackupConfig) -> None: ...
-    async def update(self, *, create_backup: CreateBackupParametersDict | UndefinedType = ..., retention: RetentionParametersDict | UndefinedType = ..., schedule: ScheduleState | UndefinedType = ...) -> None: ...
+    async def update(self, *, agents: dict[str, AgentParametersDict] | UndefinedType = ..., create_backup: CreateBackupParametersDict | UndefinedType = ..., retention: RetentionParametersDict | UndefinedType = ..., schedule: ScheduleParametersDict | UndefinedType = ...) -> None: ...
+
+@dataclass(kw_only=True)
+class AgentConfig:
+    protected: bool
+    def to_dict(self) -> StoredAgentConfig: ...
+
+class StoredAgentConfig(TypedDict):
+    protected: bool
+
+class AgentParametersDict(TypedDict, total=False):
+    protected: bool
 
 @dataclass(kw_only=True)
 class RetentionConfig:
@@ -61,7 +75,30 @@ class RetentionParametersDict(TypedDict, total=False):
     days: int | None
 
 class StoredBackupSchedule(TypedDict):
+    days: list[Day]
+    recurrence: ScheduleRecurrence
     state: ScheduleState
+    time: str | None
+
+class ScheduleParametersDict(TypedDict, total=False):
+    days: list[Day]
+    recurrence: ScheduleRecurrence
+    state: ScheduleState
+    time: dt.time | None
+
+class Day(StrEnum):
+    MONDAY = 'mon'
+    TUESDAY = 'tue'
+    WEDNESDAY = 'wed'
+    THURSDAY = 'thu'
+    FRIDAY = 'fri'
+    SATURDAY = 'sat'
+    SUNDAY = 'sun'
+
+class ScheduleRecurrence(StrEnum):
+    NEVER = 'never'
+    DAILY = 'daily'
+    CUSTOM_DAYS = 'custom_days'
 
 class ScheduleState(StrEnum):
     NEVER = 'never'
@@ -76,8 +113,13 @@ class ScheduleState(StrEnum):
 
 @dataclass(kw_only=True)
 class BackupSchedule:
+    days: list[Day] = field(default_factory=list)
+    recurrence: ScheduleRecurrence = ...
     state: ScheduleState = ...
+    time: dt.time | None = ...
     cron_event: CronSim | None = field(init=False, default=None)
+    next_automatic_backup: datetime | None = field(init=False, default=None)
+    next_automatic_backup_additional = ...
     @callback
     def apply(self, manager: BackupManager) -> None: ...
     @callback
@@ -115,5 +157,5 @@ class CreateBackupParametersDict(TypedDict, total=False):
     name: str | None
     password: str | None
 
-async def _delete_filtered_backups(manager: BackupManager, backup_filter: Callable[[dict[str, ManagerBackup]], dict[str, ManagerBackup]]) -> None: ...
+def _automatic_backups_filter(backups: dict[str, ManagerBackup]) -> dict[str, ManagerBackup]: ...
 async def delete_backups_exceeding_configured_count(manager: BackupManager) -> None: ...

homeassistant-stubs/components/backup/http.pyi

@@ -1,9 +1,14 @@
+from . import util as util
+from .agent import BackupAgent as BackupAgent
 from .const import DATA_MANAGER as DATA_MANAGER
+from .manager import BackupManager as BackupManager
+from .models import BackupNotFound as BackupNotFound
 from aiohttp.web import FileResponse, Request as Request, Response, StreamResponse
 from homeassistant.components.http import HomeAssistantView as HomeAssistantView, KEY_HASS as KEY_HASS, require_admin as require_admin
 from homeassistant.core import HomeAssistant as HomeAssistant, callback as callback
 from homeassistant.exceptions import HomeAssistantError as HomeAssistantError
 from homeassistant.util import slugify as slugify
+from multidict import istr
 
 @callback
 def async_register_http_views(hass: HomeAssistant) -> None: ...
@@ -12,9 +17,12 @@ class DownloadBackupView(HomeAssistantView):
     url: str
     name: str
     async def get(self, request: Request, backup_id: str) -> StreamResponse | FileResponse | Response: ...
+    async def _send_backup_no_password(self, request: Request, headers: dict[istr, str], backup_id: str, agent_id: str, agent: BackupAgent, manager: BackupManager) -> StreamResponse | FileResponse | Response: ...
+    async def _send_backup_with_password(self, hass: HomeAssistant, request: Request, headers: dict[istr, str], backup_id: str, agent_id: str, password: str, agent: BackupAgent, manager: BackupManager) -> StreamResponse | FileResponse | Response: ...
 
 class UploadBackupView(HomeAssistantView):
     url: str
     name: str
     @require_admin
     async def post(self, request: Request) -> Response: ...
+    async def _post(self, request: Request) -> Response: ...

homeassistant-stubs/components/backup/manager.pyi

@@ -4,16 +4,15 @@ import asyncio
 from .agent import BackupAgent as BackupAgent, BackupAgentError as BackupAgentError, BackupAgentPlatformProtocol as BackupAgentPlatformProtocol, LocalBackupAgent as LocalBackupAgent
 from .config import BackupConfig as BackupConfig, delete_backups_exceeding_configured_count as delete_backups_exceeding_configured_count
 from .const import BUF_SIZE as BUF_SIZE, DATA_MANAGER as DATA_MANAGER, DOMAIN as DOMAIN, EXCLUDE_DATABASE_FROM_BACKUP as EXCLUDE_DATABASE_FROM_BACKUP, EXCLUDE_FROM_BACKUP as EXCLUDE_FROM_BACKUP, LOGGER as LOGGER
-from .models import AgentBackup as AgentBackup, BackupManagerError as BackupManagerError, Folder as Folder
+from .models import AgentBackup as AgentBackup, BackupError as BackupError, BackupManagerError as BackupManagerError, BackupReaderWriterError as BackupReaderWriterError, BaseBackup as BaseBackup, Folder as Folder
 from .store import BackupStore as BackupStore
-from .util import make_backup_dir as make_backup_dir, read_backup as read_backup, validate_password as validate_password
+from .util import AsyncIteratorReader as AsyncIteratorReader, DecryptedBackupStreamer as DecryptedBackupStreamer, EncryptedBackupStreamer as EncryptedBackupStreamer, make_backup_dir as make_backup_dir, read_backup as read_backup, validate_password as validate_password, validate_password_stream as validate_password_stream
 from _typeshed import Incomplete
 from collections.abc import AsyncIterator, Callable as Callable, Coroutine
 from dataclasses import dataclass
 from enum import StrEnum
-from homeassistant.backup_restore import RESTORE_BACKUP_FILE as RESTORE_BACKUP_FILE, password_to_key as password_to_key
+from homeassistant.backup_restore import RESTORE_BACKUP_FILE as RESTORE_BACKUP_FILE, RESTORE_BACKUP_RESULT_FILE as RESTORE_BACKUP_RESULT_FILE, password_to_key as password_to_key
 from homeassistant.core import HomeAssistant as HomeAssistant, callback as callback
-from homeassistant.exceptions import HomeAssistantError as HomeAssistantError
 from homeassistant.helpers import instance_id as instance_id, integration_platform as integration_platform
 from homeassistant.helpers.json import json_bytes as json_bytes
 from pathlib import Path
@@ -24,8 +23,13 @@ class NewBackup:
     backup_job_id: str
 
 @dataclass(frozen=True, kw_only=True, slots=True)
-class ManagerBackup(AgentBackup):
-    agent_ids: list[str]
+class AgentBackupStatus:
+    protected: bool
+    size: int
+
+@dataclass(frozen=True, kw_only=True, slots=True)
+class ManagerBackup(BaseBackup):
+    agents: dict[str, AgentBackupStatus]
     failed_agent_ids: list[str]
     with_automatic_settings: bool | None
 
@@ -79,6 +83,7 @@ class RestoreBackupStage(StrEnum):
 
 class RestoreBackupState(StrEnum):
     COMPLETED = 'completed'
+    CORE_RESTART = 'core_restart'
     FAILED = 'failed'
     IN_PROGRESS = 'in_progress'
 
@@ -93,18 +98,21 @@ class IdleEvent(ManagerStateEvent):
 @dataclass(frozen=True, kw_only=True, slots=True)
 class CreateBackupEvent(ManagerStateEvent):
     manager_state: BackupManagerState = ...
+    reason: str | None
     stage: CreateBackupStage | None
     state: CreateBackupState
 
 @dataclass(frozen=True, kw_only=True, slots=True)
 class ReceiveBackupEvent(ManagerStateEvent):
     manager_state: BackupManagerState = ...
+    reason: str | None
     stage: ReceiveBackupStage | None
     state: ReceiveBackupState
 
 @dataclass(frozen=True, kw_only=True, slots=True)
 class RestoreBackupEvent(ManagerStateEvent):
     manager_state: BackupManagerState = ...
+    reason: str | None
     stage: RestoreBackupStage | None
     state: RestoreBackupState
 
@@ -114,14 +122,21 @@ class BackupPlatformProtocol(Protocol):
 
 class BackupReaderWriter(abc.ABC, metaclass=abc.ABCMeta):
     @abc.abstractmethod
-    async def async_create_backup(self, *, agent_ids: list[str], backup_name: str, extra_metadata: dict[str, bool | str], include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, on_progress: Callable[[ManagerStateEvent], None], password: str | None) -> tuple[NewBackup, asyncio.Task[WrittenBackup]]: ...
+    async def async_create_backup(self, *, agent_ids: list[str], backup_name: str, extra_metadata: dict[str, bool | str], include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, on_progress: Callable[[CreateBackupEvent], None], password: str | None) -> tuple[NewBackup, asyncio.Task[WrittenBackup]]: ...
     @abc.abstractmethod
     async def async_receive_backup(self, *, agent_ids: list[str], stream: AsyncIterator[bytes], suggested_filename: str) -> WrittenBackup: ...
     @abc.abstractmethod
-    async def async_restore_backup(self, backup_id: str, *, agent_id: str, open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]], password: str | None, restore_addons: list[str] | None, restore_database: bool, restore_folders: list[Folder] | None, restore_homeassistant: bool) -> None: ...
+    async def async_restore_backup(self, backup_id: str, *, agent_id: str, on_progress: Callable[[RestoreBackupEvent], None], open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]], password: str | None, restore_addons: list[str] | None, restore_database: bool, restore_folders: list[Folder] | None, restore_homeassistant: bool) -> None: ...
+    @abc.abstractmethod
+    async def async_resume_restore_progress_after_restart(self, *, on_progress: Callable[[RestoreBackupEvent | IdleEvent], None]) -> None: ...
+
+class IncorrectPasswordError(BackupReaderWriterError):
+    error_code: str
+    _message: str
 
-class BackupReaderWriterError(HomeAssistantError): ...
-class IncorrectPasswordError(BackupReaderWriterError): ...
+class DecryptOnDowloadNotSupported(BackupManagerError):
+    error_code: str
+    _message: str
 
 class BackupManager:
     hass: Incomplete
@@ -138,6 +153,7 @@ class BackupManager:
     remove_next_backup_event: Callable[[], None] | None
     remove_next_delete_event: Callable[[], None] | None
     last_event: ManagerStateEvent
+    last_non_idle_event: ManagerStateEvent | None
     _backup_event_subscriptions: list[Callable[[ManagerStateEvent], None]]
     def __init__(self, hass: HomeAssistant, reader_writer: BackupReaderWriter) -> None: ...
     async def async_setup(self) -> None: ...
@@ -152,18 +168,20 @@ class BackupManager:
     async def async_pre_backup_actions(self) -> None: ...
     async def async_post_backup_actions(self) -> None: ...
     async def load_platforms(self) -> None: ...
-    async def _async_upload_backup(self, *, backup: AgentBackup, agent_ids: list[str], open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]]) -> dict[str, Exception]: ...
+    async def _async_upload_backup(self, *, backup: AgentBackup, agent_ids: list[str], open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]], password: str | None) -> dict[str, Exception]: ...
     async def async_get_backups(self) -> tuple[dict[str, ManagerBackup], dict[str, Exception]]: ...
     async def async_get_backup(self, backup_id: str) -> tuple[ManagerBackup | None, dict[str, Exception]]: ...
     @staticmethod
     def is_our_automatic_backup(backup: AgentBackup, our_instance_id: str) -> bool | None: ...
     async def async_delete_backup(self, backup_id: str) -> dict[str, Exception]: ...
-    async def async_receive_backup(self, *, agent_ids: list[str], contents: aiohttp.BodyPartReader) -> None: ...
-    async def _async_receive_backup(self, *, agent_ids: list[str], contents: aiohttp.BodyPartReader) -> None: ...
-    async def async_create_backup(self, *, agent_ids: list[str], include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, name: str | None, password: str | None, with_automatic_settings: bool = False) -> NewBackup: ...
-    async def async_initiate_backup(self, *, agent_ids: list[str], include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, name: str | None, password: str | None, raise_task_error: bool = False, with_automatic_settings: bool = False) -> NewBackup: ...
-    async def _async_create_backup(self, *, agent_ids: list[str], include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, name: str | None, password: str | None, raise_task_error: bool, with_automatic_settings: bool) -> NewBackup: ...
-    async def _async_finish_backup(self, agent_ids: list[str], with_automatic_settings: bool) -> None: ...
+    async def async_delete_filtered_backups(self, *, include_filter: Callable[[dict[str, ManagerBackup]], dict[str, ManagerBackup]], delete_filter: Callable[[dict[str, ManagerBackup]], dict[str, ManagerBackup]]) -> None: ...
+    async def async_receive_backup(self, *, agent_ids: list[str], contents: aiohttp.BodyPartReader) -> str: ...
+    async def _async_receive_backup(self, *, agent_ids: list[str], contents: aiohttp.BodyPartReader) -> str: ...
+    async def async_create_backup(self, *, agent_ids: list[str], extra_metadata: dict[str, bool | str] | None = None, include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, name: str | None, password: str | None, with_automatic_settings: bool = False) -> NewBackup: ...
+    async def async_create_automatic_backup(self) -> NewBackup: ...
+    async def async_initiate_backup(self, *, agent_ids: list[str], extra_metadata: dict[str, bool | str] | None = None, include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, name: str | None, password: str | None, raise_task_error: bool = False, with_automatic_settings: bool = False) -> NewBackup: ...
+    async def _async_create_backup(self, *, agent_ids: list[str], extra_metadata: dict[str, bool | str] | None, include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, name: str | None, password: str | None, raise_task_error: bool, with_automatic_settings: bool) -> NewBackup: ...
+    async def _async_finish_backup(self, available_agents: list[str], unavailable_agents: list[str], with_automatic_settings: bool, password: str | None) -> None: ...
     async def async_restore_backup(self, backup_id: str, *, agent_id: str, password: str | None, restore_addons: list[str] | None, restore_database: bool, restore_folders: list[Folder] | None, restore_homeassistant: bool) -> None: ...
     async def _async_restore_backup(self, backup_id: str, *, agent_id: str, password: str | None, restore_addons: list[str] | None, restore_database: bool, restore_folders: list[Folder] | None, restore_homeassistant: bool) -> None: ...
     @callback
@@ -171,7 +189,8 @@ class BackupManager:
     @callback
     def async_subscribe_events(self, on_event: Callable[[ManagerStateEvent], None]) -> Callable[[], None]: ...
     def _update_issue_backup_failed(self) -> None: ...
-    def _update_issue_after_agent_upload(self, agent_errors: dict[str, Exception]) -> None: ...
+    def _update_issue_after_agent_upload(self, agent_errors: dict[str, Exception], unavailable_agents: list[str]) -> None: ...
+    async def async_can_decrypt_on_download(self, backup_id: str, *, agent_id: str, password: str | None) -> None: ...
 
 class KnownBackups:
     _backups: dict[str, KnownBackup]
@@ -179,7 +198,7 @@ class KnownBackups:
     def __init__(self, manager: BackupManager) -> None: ...
     def load(self, stored_backups: list[StoredKnownBackup]) -> None: ...
     def to_list(self) -> list[StoredKnownBackup]: ...
-    def add(self, backup: AgentBackup, agent_errors: dict[str, Exception]) -> None: ...
+    def add(self, backup: AgentBackup, agent_errors: dict[str, Exception], unavailable_agents: list[str]) -> None: ...
     def get(self, backup_id: str) -> KnownBackup | None: ...
     def remove(self, backup_id: str) -> None: ...
 
@@ -198,10 +217,11 @@ class CoreBackupReaderWriter(BackupReaderWriter):
     _hass: Incomplete
     temp_backup_dir: Incomplete
     def __init__(self, hass: HomeAssistant) -> None: ...
-    async def async_create_backup(self, *, agent_ids: list[str], backup_name: str, extra_metadata: dict[str, bool | str], include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, on_progress: Callable[[ManagerStateEvent], None], password: str | None) -> tuple[NewBackup, asyncio.Task[WrittenBackup]]: ...
-    async def _async_create_backup(self, *, agent_ids: list[str], backup_id: str, backup_name: str, date_str: str, extra_metadata: dict[str, bool | str], include_database: bool, on_progress: Callable[[ManagerStateEvent], None], password: str | None) -> WrittenBackup: ...
+    async def async_create_backup(self, *, agent_ids: list[str], backup_name: str, extra_metadata: dict[str, bool | str], include_addons: list[str] | None, include_all_addons: bool, include_database: bool, include_folders: list[Folder] | None, include_homeassistant: bool, on_progress: Callable[[CreateBackupEvent], None], password: str | None) -> tuple[NewBackup, asyncio.Task[WrittenBackup]]: ...
+    async def _async_create_backup(self, *, agent_ids: list[str], backup_id: str, backup_name: str, date_str: str, extra_metadata: dict[str, bool | str], include_database: bool, on_progress: Callable[[CreateBackupEvent], None], password: str | None) -> WrittenBackup: ...
     def _mkdir_and_generate_backup_contents(self, backup_data: dict[str, Any], database_included: bool, password: str | None, tar_file_path: Path | None) -> tuple[Path, int]: ...
     async def async_receive_backup(self, *, agent_ids: list[str], stream: AsyncIterator[bytes], suggested_filename: str) -> WrittenBackup: ...
-    async def async_restore_backup(self, backup_id: str, open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]], *, agent_id: str, password: str | None, restore_addons: list[str] | None, restore_database: bool, restore_folders: list[Folder] | None, restore_homeassistant: bool) -> None: ...
+    async def async_restore_backup(self, backup_id: str, open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]], *, agent_id: str, on_progress: Callable[[RestoreBackupEvent], None], password: str | None, restore_addons: list[str] | None, restore_database: bool, restore_folders: list[Folder] | None, restore_homeassistant: bool) -> None: ...
+    async def async_resume_restore_progress_after_restart(self, *, on_progress: Callable[[RestoreBackupEvent | IdleEvent], None]) -> None: ...
 
 def _generate_backup_id(date: str, name: str) -> str: ...

homeassistant-stubs/components/backup/models.pyi

@@ -16,7 +16,7 @@ class Folder(StrEnum):
     MEDIA = 'media'
 
 @dataclass(frozen=True, kw_only=True)
-class AgentBackup:
+class BaseBackup:
     addons: list[AddonInfo]
     backup_id: str
     date: str
@@ -26,11 +26,26 @@ class AgentBackup:
     homeassistant_included: bool
     homeassistant_version: str | None
     name: str
+
+@dataclass(frozen=True, kw_only=True)
+class AgentBackup(BaseBackup):
     protected: bool
     size: int
     def as_dict(self) -> dict: ...
-    def as_frontend_json(self) -> dict: ...
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> Self: ...
 
-class BackupManagerError(HomeAssistantError): ...
+class BackupError(HomeAssistantError):
+    error_code: str
+
+class BackupAgentError(BackupError):
+    error_code: str
+
+class BackupManagerError(BackupError):
+    error_code: str
+
+class BackupReaderWriterError(BackupError):
+    error_code: str
+
+class BackupNotFound(BackupAgentError, BackupManagerError):
+    error_code: str

homeassistant-stubs/components/backup/store.pyi

@@ -4,20 +4,25 @@ from .manager import BackupManager as BackupManager, StoredKnownBackup as Stored
 from _typeshed import Incomplete
 from homeassistant.core import HomeAssistant as HomeAssistant, callback as callback
 from homeassistant.helpers.storage import Store as Store
-from typing import TypedDict
+from typing import Any, TypedDict
 
 STORE_DELAY_SAVE: int
 STORAGE_KEY = DOMAIN
 STORAGE_VERSION: int
+STORAGE_VERSION_MINOR: int
 
 class StoredBackupData(TypedDict):
     backups: list[StoredKnownBackup]
     config: StoredBackupConfig
 
+class _BackupStore(Store[StoredBackupData]):
+    def __init__(self, hass: HomeAssistant) -> None: ...
+    async def _async_migrate_func(self, old_major_version: int, old_minor_version: int, old_data: dict[str, Any]) -> dict[str, Any]: ...
+
 class BackupStore:
     _hass: Incomplete
     _manager: Incomplete
-    _store: Store[StoredBackupData]
+    _store: Incomplete
     def __init__(self, hass: HomeAssistant, manager: BackupManager) -> None: ...
     async def load(self) -> StoredBackupData | None: ...
     @callback

homeassistant-stubs/components/backup/util.pyi

@@ -1,12 +1,106 @@
 import aiohttp
+import asyncio
+import tarfile
+import threading
 from .const import BUF_SIZE as BUF_SIZE, LOGGER as LOGGER
 from .models import AddonInfo as AddonInfo, AgentBackup as AgentBackup, Folder as Folder
+from _typeshed import Incomplete
+from collections.abc import AsyncIterator, Callable as Callable, Coroutine
+from concurrent.futures import Future
+from dataclasses import dataclass
 from homeassistant.backup_restore import password_to_key as password_to_key
 from homeassistant.core import HomeAssistant as HomeAssistant
+from homeassistant.exceptions import HomeAssistantError as HomeAssistantError
 from homeassistant.util.json import JsonObjectType as JsonObjectType, json_loads_object as json_loads_object
 from pathlib import Path
+from typing import Any, IO, Self
+
+class DecryptError(HomeAssistantError):
+    _message: str
+
+class EncryptError(HomeAssistantError):
+    _message: str
+
+class UnsupportedSecureTarVersion(DecryptError):
+    _message: str
+
+class IncorrectPassword(DecryptError):
+    _message: str
+
+class BackupEmpty(DecryptError):
+    _message: str
+
+class AbortCipher(HomeAssistantError):
+    _message: str
 
 def make_backup_dir(path: Path) -> None: ...
 def read_backup(backup_path: Path) -> AgentBackup: ...
+def suggested_filename_from_name_date(name: str, date_str: str) -> str: ...
+def suggested_filename(backup: AgentBackup) -> str: ...
 def validate_password(path: Path, password: str | None) -> bool: ...
+
+class AsyncIteratorReader:
+    _aborted: bool
+    _hass: Incomplete
+    _stream: Incomplete
+    _buffer: bytes | None
+    _next_future: Future[bytes | None] | None
+    _pos: int
+    def __init__(self, hass: HomeAssistant, stream: AsyncIterator[bytes]) -> None: ...
+    async def _next(self) -> bytes | None: ...
+    def abort(self) -> None: ...
+    def read(self, n: int = -1, /) -> bytes: ...
+    def close(self) -> None: ...
+
+class AsyncIteratorWriter:
+    _aborted: bool
+    _hass: Incomplete
+    _pos: int
+    _queue: asyncio.Queue[bytes | None]
+    _write_future: Future[bytes | None] | None
+    def __init__(self, hass: HomeAssistant) -> None: ...
+    def __aiter__(self) -> Self: ...
+    async def __anext__(self) -> bytes: ...
+    def abort(self) -> None: ...
+    def tell(self) -> int: ...
+    def write(self, s: bytes, /) -> int: ...
+
+def validate_password_stream(input_stream: IO[bytes], password: str | None) -> None: ...
+def decrypt_backup(input_stream: IO[bytes], output_stream: IO[bytes], password: str | None, on_done: Callable[[Exception | None], None], minimum_size: int, nonces: list[bytes]) -> None: ...
+def _decrypt_backup(input_tar: tarfile.TarFile, output_tar: tarfile.TarFile, password: str | None) -> None: ...
+def encrypt_backup(input_stream: IO[bytes], output_stream: IO[bytes], password: str | None, on_done: Callable[[Exception | None], None], minimum_size: int, nonces: list[bytes]) -> None: ...
+def _encrypt_backup(input_tar: tarfile.TarFile, output_tar: tarfile.TarFile, password: str | None, nonces: list[bytes]) -> None: ...
+
+@dataclass(kw_only=True)
+class _CipherWorkerStatus:
+    done: asyncio.Event
+    error: Exception | None = ...
+    reader: AsyncIteratorReader
+    thread: threading.Thread
+    writer: AsyncIteratorWriter
+
+class _CipherBackupStreamer:
+    _cipher_func: Callable[[IO[bytes], IO[bytes], str | None, Callable[[Exception | None], None], int, list[bytes]], None]
+    _workers: list[_CipherWorkerStatus]
+    _backup: Incomplete
+    _hass: Incomplete
+    _open_stream: Incomplete
+    _password: Incomplete
+    _nonces: list[bytes]
+    def __init__(self, hass: HomeAssistant, backup: AgentBackup, open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]], password: str | None) -> None: ...
+    def size(self) -> int: ...
+    def _num_tar_files(self) -> int: ...
+    async def open_stream(self) -> AsyncIterator[bytes]: ...
+    async def wait(self) -> None: ...
+
+class DecryptedBackupStreamer(_CipherBackupStreamer):
+    _cipher_func: Incomplete
+    def backup(self) -> AgentBackup: ...
+
+class EncryptedBackupStreamer(_CipherBackupStreamer):
+    _nonces: Incomplete
+    def __init__(self, hass: HomeAssistant, backup: AgentBackup, open_stream: Callable[[], Coroutine[Any, Any, AsyncIterator[bytes]]], password: str | None) -> None: ...
+    _cipher_func: Incomplete
+    def backup(self) -> AgentBackup: ...
+
 async def receive_file(hass: HomeAssistant, contents: aiohttp.BodyPartReader, path: Path) -> None: ...

homeassistant-stubs/components/backup/websocket.pyi

@@ -1,7 +1,7 @@
-from .config import ScheduleState as ScheduleState
+from .config import Day as Day, ScheduleRecurrence as ScheduleRecurrence
 from .const import DATA_MANAGER as DATA_MANAGER, LOGGER as LOGGER
-from .manager import IncorrectPasswordError as IncorrectPasswordError, ManagerStateEvent as ManagerStateEvent
-from .models import Folder as Folder
+from .manager import DecryptOnDowloadNotSupported as DecryptOnDowloadNotSupported, IncorrectPasswordError as IncorrectPasswordError, ManagerStateEvent as ManagerStateEvent
+from .models import BackupNotFound as BackupNotFound, Folder as Folder
 from homeassistant.components import websocket_api as websocket_api
 from homeassistant.core import HomeAssistant as HomeAssistant, callback as callback
 from typing import Any
@@ -22,6 +22,9 @@ async def handle_delete(hass: HomeAssistant, connection: websocket_api.ActiveCon
 async def handle_restore(hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any]) -> None: ...
 @websocket_api.require_admin
 @websocket_api.async_response
+async def handle_can_decrypt_on_download(hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any]) -> None: ...
+@websocket_api.require_admin
+@websocket_api.async_response
 async def handle_create(hass: HomeAssistant, connection: websocket_api.ActiveConnection, msg: dict[str, Any]) -> None: ...
 @websocket_api.require_admin
 @websocket_api.async_response

homeassistant-stubs/components/baf/config_flow.pyi

@@ -2,9 +2,9 @@ from .const import DOMAIN as DOMAIN, RUN_TIMEOUT as RUN_TIMEOUT
 from .models import BAFDiscovery as BAFDiscovery
 from _typeshed import Incomplete
 from aiobafi6 import Device
-from homeassistant.components import zeroconf as zeroconf
 from homeassistant.config_entries import ConfigFlow as ConfigFlow, ConfigFlowResult as ConfigFlowResult
 from homeassistant.const import CONF_IP_ADDRESS as CONF_IP_ADDRESS
+from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo as ZeroconfServiceInfo
 from typing import Any
 
 _LOGGER: Incomplete
@@ -15,7 +15,7 @@ class BAFFlowHandler(ConfigFlow, domain=DOMAIN):
     VERSION: int
     discovery: BAFDiscovery | None
     def __init__(self) -> None: ...
-    async def async_step_zeroconf(self, discovery_info: zeroconf.ZeroconfServiceInfo) -> ConfigFlowResult: ...
+    async def async_step_zeroconf(self, discovery_info: ZeroconfServiceInfo) -> ConfigFlowResult: ...
     async def async_step_discovery_confirm(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult: ...
     async def async_step_user(self, user_input: dict[str, Any] | None = None) -> ConfigFlowResult: ...
 

homeassistant-stubs/components/bang_olufsen/config_flow.pyi

@@ -1,10 +1,10 @@
 from .const import ATTR_FRIENDLY_NAME as ATTR_FRIENDLY_NAME, ATTR_ITEM_NUMBER as ATTR_ITEM_NUMBER, ATTR_SERIAL_NUMBER as ATTR_SERIAL_NUMBER, ATTR_TYPE_NUMBER as ATTR_TYPE_NUMBER, COMPATIBLE_MODELS as COMPATIBLE_MODELS, CONF_SERIAL_NUMBER as CONF_SERIAL_NUMBER, DEFAULT_MODEL as DEFAULT_MODEL, DOMAIN as DOMAIN
 from .util import get_serial_number_from_jid as get_serial_number_from_jid
 from _typeshed import Incomplete
-from homeassistant.components.zeroconf import ZeroconfServiceInfo as ZeroconfServiceInfo
 from homeassistant.config_entries import ConfigFlow as ConfigFlow, ConfigFlowResult as ConfigFlowResult
 from homeassistant.const import CONF_HOST as CONF_HOST, CONF_MODEL as CONF_MODEL
 from homeassistant.helpers.selector import SelectSelector as SelectSelector, SelectSelectorConfig as SelectSelectorConfig
+from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo as ZeroconfServiceInfo
 from homeassistant.util.ssl import get_default_context as get_default_context
 from mozart_api.mozart_client import MozartClient
 from typing import Any, TypedDict

homeassistant-stubs/components/bang_olufsen/const.pyi

@@ -35,6 +35,7 @@ class BangOlufsenModel(StrEnum):
 
 class WebsocketNotification(StrEnum):
     ACTIVE_LISTENING_MODE = 'active_listening_mode'
+    BUTTON = 'button'
     PLAYBACK_ERROR = 'playback_error'
     PLAYBACK_METADATA = 'playback_metadata'
     PLAYBACK_PROGRESS = 'playback_progress'
@@ -64,7 +65,12 @@ ATTR_FRIENDLY_NAME: Final[str]
 BANG_OLUFSEN_ON: Final[str]
 VALID_MEDIA_TYPES: Final[tuple]
 FALLBACK_SOURCES: Final[SourceArray]
+MODEL_SUPPORT_DEVICE_BUTTONS: Final[str]
+MODEL_SUPPORT_MAP: Incomplete
 BANG_OLUFSEN_WEBSOCKET_EVENT: Final[str]
+EVENT_TRANSLATION_MAP: dict[str, str]
 CONNECTION_STATUS: Final[str]
+DEVICE_BUTTONS: Final[list[str]]
+DEVICE_BUTTON_EVENTS: Final[list[str]]
 BEOLINK_JOIN_SOURCES_TO_UPPER: Incomplete
 BEOLINK_JOIN_SOURCES: Incomplete