"""Provide methods to bootstrap a Home Assistant instance."""

from __future__ import annotations

import asyncio

from collections import defaultdict

import contextlib

from functools import partial

from itertools import chain

import logging

import logging.handlers

from operator import contains, itemgetter

import os

import platform

import sys

import threading

from time import monotonic

from typing import TYPE_CHECKING, Any

# Import cryptography early since import openssl is not thread-safe

# _frozen_importlib._DeadlockError: deadlock detected by _ModuleLock('cryptography.hazmat.backends.openssl.backend')

import cryptography.hazmat.backends.openssl.backend # noqa: F401

import voluptuous as vol

import yarl

from . import config as conf_util, config_entries, core, loader, requirements

# Pre-import frontend deps which have no requirements here to avoid

# loading them at run time and blocking the event loop. We do this ahead

# of time so that we do not have to flag frontend deps with `import_executor`

# as it would create a thundering heard of executor jobs trying to import

# frontend deps at the same time.

from .components import (

api as api_pre_import, # noqa: F401

auth as auth_pre_import, # noqa: F401

config as config_pre_import, # noqa: F401

default_config as default_config_pre_import, # noqa: F401

device_automation as device_automation_pre_import, # noqa: F401

diagnostics as diagnostics_pre_import, # noqa: F401

file_upload as file_upload_pre_import, # noqa: F401

group as group_pre_import, # noqa: F401

history as history_pre_import, # noqa: F401

http, # not named pre_import since it has requirements

image_upload as image_upload_import, # noqa: F401 - not named pre_import since it has requirements

logbook as logbook_pre_import, # noqa: F401

lovelace as lovelace_pre_import, # noqa: F401

onboarding as onboarding_pre_import, # noqa: F401

recorder as recorder_import, # noqa: F401 - not named pre_import since it has requirements

repairs as repairs_pre_import, # noqa: F401

search as search_pre_import, # noqa: F401

sensor as sensor_pre_import, # noqa: F401

system_log as system_log_pre_import, # noqa: F401

webhook as webhook_pre_import, # noqa: F401

websocket_api as websocket_api_pre_import, # noqa: F401

)

from .components.sensor import recorder as sensor_recorder # noqa: F401

from .const import (

FORMAT_DATETIME,

KEY_DATA_LOGGING as DATA_LOGGING,

REQUIRED_NEXT_PYTHON_HA_RELEASE,

REQUIRED_NEXT_PYTHON_VER,

SIGNAL_BOOTSTRAP_INTEGRATIONS,

)

from .exceptions import HomeAssistantError

from .helpers import (

area_registry,

category_registry,

config_validation as cv,

device_registry,

entity,

entity_registry,

floor_registry,

issue_registry,

label_registry,

recorder,

restore_state,

template,

translation,

)

from .helpers.dispatcher import async_dispatcher_send

from .helpers.typing import ConfigType

from .setup import (

BASE_PLATFORMS,

DATA_SETUP_STARTED,

async_get_setup_timings,

async_notify_setup_error,

async_set_domains_to_be_loaded,

async_setup_component,

)

from .util.async_ import create_eager_task

from .util.logging import async_activate_log_queue_handler

from .util.package import async_get_user_site, is_virtual_env

if TYPE_CHECKING:

from .runner import RuntimeConfig

_LOGGER = logging.getLogger(__name__)

SETUP_ORDER_SORT_KEY = partial(contains, BASE_PLATFORMS)

ERROR_LOG_FILENAME = "home-assistant.log"

# hass.data key for logging information.

DATA_REGISTRIES_LOADED = "bootstrap_registries_loaded"

LOG_SLOW_STARTUP_INTERVAL = 60

SLOW_STARTUP_CHECK_INTERVAL = 1

STAGE_1_TIMEOUT = 120

STAGE_2_TIMEOUT = 300

WRAP_UP_TIMEOUT = 300

COOLDOWN_TIME = 60

DEBUGGER_INTEGRATIONS = {"debugpy"}

CORE_INTEGRATIONS = {"homeassistant", "persistent_notification"}

LOGGING_INTEGRATIONS = {

}

FRONTEND_INTEGRATIONS = {

}

RECORDER_INTEGRATIONS = {

}

DISCOVERY_INTEGRATIONS = ("bluetooth", "dhcp", "ssdp", "usb", "zeroconf")

STAGE_1_INTEGRATIONS = {

}

DEFAULT_INTEGRATIONS = {

}

DEFAULT_INTEGRATIONS_RECOVERY_MODE = {

# These integrations are set up if recovery mode is activated.

"frontend",

}

DEFAULT_INTEGRATIONS_SUPERVISOR = {

# These integrations are set up if using the Supervisor

"hassio",

}

CRITICAL_INTEGRATIONS = {

# Recovery mode is activated if these integrations fail to set up

"frontend",

}

SETUP_ORDER = {

}

async def async_setup_hass(

return hass

def open_hass_ui(hass: core.HomeAssistant) -> None:

)

async def async_load_base_functionality(hass: core.HomeAssistant) -> None:

)

async def async_from_config_dict(

return hass

@core.callback

def async_enable_logging(

async_activate_log_queue_handler(hass)

async def async_mount_local_lib_path(config_dir: str) -> str:

return deps_dir

@core.callback

def _get_domains(hass: core.HomeAssistant, config: dict[str, Any]) -> set[str]:

return domains

class _WatchPendingSetups:

self._handle = None

async def async_setup_multi_components(

)

async def _async_resolve_domains_to_setup(

return domains_to_setup, integration_cache

async def _async_set_up_integrations(

)