def test_deprecated_with_replacement_key_and_invalidation_version(
caplog, schema, version
):
"""
Test deprecation behaves with a replacement key & invalidation_version.
Expected behavior:
- Outputs the appropriate deprecation warning if key is detected
- Processes schema moving the value from key to replacement_key
- Processes schema changing nothing if only replacement_key provided
- No warning if only replacement_key provided
- No warning or difference in output if neither key nor
replacement_key are provided
- Once the invalidation_version is crossed, raises vol.Invalid if key
is detected
"""
deprecated_schema = vol.All(
cv.deprecated(
'mars', replacement_key='jupiter', invalidation_version='1.0.0'
),
schema
)
warning = ("The 'mars' option (with value 'True') is deprecated, "
"please replace it with 'jupiter'. This option will become "
"invalid in version 1.0.0")
test_data = {'mars': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 1
assert warning in caplog.text
assert {'jupiter': True} == output
caplog.clear()
assert len(caplog.records) == 0
test_data = {'jupiter': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert test_data == output
test_data = {'venus': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert test_data == output
invalidated_schema = vol.All(
cv.deprecated(
'mars', replacement_key='jupiter', invalidation_version='0.1.0'
),
schema
)
test_data = {'mars': True}
with pytest.raises(vol.MultipleInvalid) as exc_info:
invalidated_schema(test_data)
assert ("The 'mars' option (with value 'True') is deprecated, "
"please replace it with 'jupiter'. This option will become "
"invalid in version 0.1.0") == str(exc_info.value)
def test_deprecated_with_replacement_key_and_default(caplog, schema):
"""
Test deprecation with a replacement key and default.
Expected behavior:
- Outputs the appropriate deprecation warning if key is detected
- Processes schema moving the value from key to replacement_key
- Processes schema changing nothing if only replacement_key provided
- No warning if only replacement_key provided
- No warning if neither key nor replacement_key are provided
- Adds replacement_key with default value in this case
"""
deprecated_schema = vol.All(
cv.deprecated('mars', replacement_key='jupiter', default=False),
schema
)
test_data = {'mars': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 1
assert ("The 'mars' option (with value 'True') is deprecated, "
"please replace it with 'jupiter'") in caplog.text
assert {'jupiter': True} == output
caplog.clear()
assert len(caplog.records) == 0
test_data = {'jupiter': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert test_data == output
test_data = {'venus': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert {'venus': True, 'jupiter': False} == output
deprecated_schema_with_default = vol.All(
vol.Schema({
'venus': cv.boolean,
vol.Optional('mars', default=False): cv.boolean,
vol.Optional('jupiter', default=False): cv.boolean
}),
cv.deprecated('mars', replacement_key='jupiter', default=False)
)
test_data = {'mars': True}
output = deprecated_schema_with_default(test_data.copy())
assert len(caplog.records) == 1
assert ("The 'mars' option (with value 'True') is deprecated, "
"please replace it with 'jupiter'") in caplog.text
assert {'jupiter': True} == output
def test_deprecated_with_no_optionals(caplog, schema):
"""
Test deprecation behaves correctly when optional params are None.
Expected behavior:
- Outputs the appropriate deprecation warning if key is detected
- Processes schema without changing any values
- No warning or difference in output if key is not provided
"""
deprecated_schema = vol.All(
cv.deprecated('mars'),
schema
)
test_data = {'mars': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 1
assert caplog.records[0].name == __name__
assert ("The 'mars' option (with value 'True') is deprecated, "
"please remove it from your configuration") in caplog.text
assert test_data == output
caplog.clear()
assert len(caplog.records) == 0
test_data = {'venus': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert test_data == output
def test_deprecated_with_default(caplog, schema):
"""
Test deprecation behaves correctly with a default value.
This is likely a scenario that would never occur.
Expected behavior:
- Behaves identically as when the default value was not present
"""
deprecated_schema = vol.All(
cv.deprecated('mars', default=False),
schema
)
test_data = {'mars': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 1
assert caplog.records[0].name == __name__
assert ("The 'mars' option (with value 'True') is deprecated, "
"please remove it from your configuration") in caplog.text
assert test_data == output
caplog.clear()
assert len(caplog.records) == 0
test_data = {'venus': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert test_data == output
def test_deprecated_with_invalidation_version(caplog, schema, version):
"""
Test deprecation behaves correctly with only an invalidation_version.
Expected behavior:
- Outputs the appropriate deprecation warning if key is detected
- Processes schema without changing any values
- No warning or difference in output if key is not provided
- Once the invalidation_version is crossed, raises vol.Invalid if key
is detected
"""
deprecated_schema = vol.All(
cv.deprecated('mars', invalidation_version='1.0.0'),
schema
)
message = ("The 'mars' option (with value 'True') is deprecated, "
"please remove it from your configuration. "
"This option will become invalid in version 1.0.0")
test_data = {'mars': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 1
assert message in caplog.text
assert test_data == output
caplog.clear()
assert len(caplog.records) == 0
test_data = {'venus': False}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert test_data == output
invalidated_schema = vol.All(
cv.deprecated('mars', invalidation_version='0.1.0'),
schema
)
test_data = {'mars': True}
with pytest.raises(vol.MultipleInvalid) as exc_info:
invalidated_schema(test_data)
assert ("The 'mars' option (with value 'True') is deprecated, "
"please remove it from your configuration. This option will "
"become invalid in version 0.1.0") == str(exc_info.value)
def test_deprecated(caplog):
"""Test deprecation log."""
schema = vol.Schema({
'venus': cv.boolean,
'mars': cv.boolean
})
deprecated_schema = vol.All(
cv.deprecated('mars'),
schema
)
deprecated_schema({'venus': True})
assert len(caplog.records) == 0
deprecated_schema({'mars': True})
assert len(caplog.records) == 1
assert caplog.records[0].name == __name__
assert ("The 'mars' option (with value 'True') is deprecated, "
"please remove it from your configuration.") in caplog.text
def test_deprecated_with_replacement_key(caplog, schema):
"""
Test deprecation behaves correctly when only a replacement key is provided.
Expected behavior:
- Outputs the appropriate deprecation warning if key is detected
- Processes schema moving the value from key to replacement_key
- Processes schema changing nothing if only replacement_key provided
- No warning if only replacement_key provided
- No warning or difference in output if neither key nor
replacement_key are provided
"""
deprecated_schema = vol.All(
cv.deprecated('mars', replacement_key='jupiter'),
schema
)
test_data = {'mars': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 1
assert ("The 'mars' option (with value 'True') is deprecated, "
"please replace it with 'jupiter'") in caplog.text
assert {'jupiter': True} == output
caplog.clear()
assert len(caplog.records) == 0
test_data = {'jupiter': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert test_data == output
test_data = {'venus': True}
output = deprecated_schema(test_data.copy())
assert len(caplog.records) == 0
assert test_data == output
vol.All(
{
vol.Required(CONF_USERNAME):
cv.string,
vol.Required(CONF_PASSWORD):
cv.string,
vol.Optional(CONF_FEEDERS):
vol.All(cv.ensure_list, [cv.positive_int]),
vol.Optional(CONF_FLAPS):
vol.All(cv.ensure_list, [cv.positive_int]),
vol.Optional(CONF_PETS):
vol.All(cv.ensure_list, [cv.positive_int]),
vol.Optional(CONF_SCAN_INTERVAL):
cv.time_period,
},
cv.deprecated(CONF_FEEDERS),
cv.deprecated(CONF_FLAPS),
cv.deprecated(CONF_PETS),
cv.deprecated(CONF_SCAN_INTERVAL),
))
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up the Sure Petcare integration."""
conf = config[DOMAIN]
hass.data.setdefault(DOMAIN, {})
try:
def ensure_unique_hosts(value):
"""Validate that all configs have a unique host."""
vol.Schema(vol.Unique("duplicate host entries found"))(
[entry[CONF_HOST] for entry in value])
return value
PLATFORMS = [MP_DOMAIN]
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.All(
cv.ensure_list,
[
cv.deprecated(CONF_PORT),
vol.Schema({
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_PORT): cv.port,
vol.Optional(CONF_ON_ACTION): cv.SCRIPT_SCHEMA,
}),
],
ensure_unique_hosts,
)
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(hass, config):
vol.Optional(CONF_UNIT_OF_MEASUREMENT):
cv.string,
vol.Optional(CONF_DEVICE_CLASS):
DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_UNIQUE_ID):
cv.string,
vol.Optional(CONF_DELAY_ON):
vol.Any(cv.positive_time_period, cv.template),
vol.Optional(CONF_DELAY_OFF):
vol.Any(cv.positive_time_period, cv.template),
vol.Optional(CONF_AUTO_OFF):
vol.Any(cv.positive_time_period, cv.template),
})
LEGACY_BINARY_SENSOR_SCHEMA = vol.All(
cv.deprecated(ATTR_ENTITY_ID),
vol.Schema({
vol.Required(CONF_VALUE_TEMPLATE):
cv.template,
vol.Optional(CONF_ICON_TEMPLATE):
cv.template,
vol.Optional(CONF_ENTITY_PICTURE_TEMPLATE):
cv.template,
vol.Optional(CONF_AVAILABILITY_TEMPLATE):
cv.template,
vol.Optional(CONF_ATTRIBUTE_TEMPLATES):
vol.Schema({cv.string: cv.template}),
vol.Optional(ATTR_FRIENDLY_NAME):
cv.string,
vol.Optional(ATTR_ENTITY_ID):
cv.entity_ids,
CONF_BROADCAST = "broadcast"
CONF_SERVER = "server"
SHORT_MAX = 65535
TEMP_MAX = 9000
TEMP_MAX_HASS = 500
TEMP_MIN = 2500
TEMP_MIN_HASS = 154
SUPPORT_LIFX = (SUPPORT_BRIGHTNESS | SUPPORT_COLOR_TEMP | SUPPORT_COLOR
| SUPPORT_TRANSITION)
PLATFORM_SCHEMA = vol.All(
cv.deprecated(CONF_SERVER),
cv.deprecated(CONF_BROADCAST),
PLATFORM_SCHEMA.extend({
vol.Optional(CONF_SERVER): cv.string,
vol.Optional(CONF_BROADCAST): cv.string
}),
)
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the LIFX platform."""
_LOGGER.warning(
"The LIFX Legacy platform is deprecated and will be removed in "
"Home Assistant Core 2021.6.0; Use the LIFX integration instead")
server_addr = config.get(CONF_SERVER)
from . import CONF_HUB, DEFAULT_HUB, DOMAIN as MODBUS_DOMAIN
_LOGGER = logging.getLogger(__name__)
CONF_DEPRECATED_COIL = "coil"
CONF_DEPRECATED_COILS = "coils"
CONF_INPUTS = "inputs"
CONF_INPUT_TYPE = "input_type"
CONF_ADDRESS = "address"
INPUT_TYPE_COIL = "coil"
INPUT_TYPE_DISCRETE = "discrete_input"
PLATFORM_SCHEMA = vol.All(
cv.deprecated(CONF_DEPRECATED_COILS, CONF_INPUTS),
PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_INPUTS): [
vol.All(
cv.deprecated(CONF_DEPRECATED_COIL, CONF_ADDRESS),
vol.Schema(
{
vol.Required(CONF_ADDRESS): cv.positive_int,
vol.Required(CONF_NAME): cv.string,
vol.Optional(CONF_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_HUB, default=DEFAULT_HUB): cv.string,
vol.Optional(CONF_SLAVE): cv.positive_int,
vol.Optional(
CONF_INPUT_TYPE, default=INPUT_TYPE_COIL
): vol.In([INPUT_TYPE_COIL, INPUT_TYPE_DISCRETE]),
SRV_CONTROLLER = 'controller'
SRV_RESPONDER = 'responder'
SRV_HOUSECODE = 'housecode'
HOUSECODES = [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p'
]
BUTTON_PRESSED_STATE_NAME = 'onLevelButton'
EVENT_BUTTON_ON = 'insteon.button_on'
EVENT_BUTTON_OFF = 'insteon.button_off'
EVENT_CONF_BUTTON = 'button'
CONF_DEVICE_OVERRIDE_SCHEMA = vol.All(
cv.deprecated(CONF_PLATFORM),
vol.Schema({
vol.Required(CONF_ADDRESS): cv.string,
vol.Optional(CONF_CAT): cv.byte,
vol.Optional(CONF_SUBCAT): cv.byte,
vol.Optional(CONF_FIRMWARE): cv.byte,
vol.Optional(CONF_PRODUCT_KEY): cv.byte,
vol.Optional(CONF_PLATFORM): cv.string,
}))
CONF_X10_SCHEMA = vol.All(
vol.Schema({
vol.Required(CONF_HOUSECODE): cv.string,
vol.Required(CONF_UNITCODE): vol.Range(min=1, max=16),
vol.Required(CONF_PLATFORM): cv.string,
vol.Optional(CONF_DIM_STEPS): vol.Range(min=2, max=255)
vol.Optional(CONF_DEVICES, default={}): {
cv.string: _ensure_device
},
}, )
DEVICE_SCHEMA = BASE_SCHEMA.extend({vol.Required(CONF_DEVICE): cv.string})
PORT_SCHEMA = BASE_SCHEMA.extend({
vol.Required(CONF_PORT): cv.port,
vol.Optional(CONF_HOST): cv.string
})
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.All(cv.deprecated(CONF_DEBUG), vol.Any(DEVICE_SCHEMA, PORT_SCHEMA))
},
extra=vol.ALLOW_EXTRA,
)
DOMAINS = ["switch", "sensor", "light", "binary_sensor", "cover"]
async def async_setup(hass, config):
"""Set up the RFXtrx component."""
if DOMAIN not in config:
return True
data = {
CONF_HOST: config[DOMAIN].get(CONF_HOST),
CONF_PORT: config[DOMAIN].get(CONF_PORT),
MQTT_WILL_BIRTH_SCHEMA = vol.Schema(
{
vol.Inclusive(ATTR_TOPIC, "topic_payload"): valid_publish_topic,
vol.Inclusive(ATTR_PAYLOAD, "topic_payload"): cv.string,
vol.Optional(ATTR_QOS, default=DEFAULT_QOS): _VALID_QOS_SCHEMA,
vol.Optional(ATTR_RETAIN, default=DEFAULT_RETAIN): cv.boolean,
},
required=True,
)
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.All(
cv.deprecated(CONF_TLS_VERSION),
vol.Schema({
vol.Optional(CONF_CLIENT_ID):
cv.string,
vol.Optional(CONF_KEEPALIVE, default=DEFAULT_KEEPALIVE):
vol.All(vol.Coerce(int), vol.Range(min=15)),
vol.Optional(CONF_BROKER):
cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT):
cv.port,
vol.Optional(CONF_USERNAME):
cv.string,
vol.Optional(CONF_PASSWORD):
cv.string,
vol.Optional(CONF_CERTIFICATE):
vol.Any("auto", cv.isfile),
from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.typing import ConfigType
from .common import Device, FritzBoxTools, FritzData, FritzDevice
from .const import DATA_FRITZ, DEFAULT_DEVICE_NAME, DOMAIN
_LOGGER = logging.getLogger(__name__)
YAML_DEFAULT_HOST = "169.254.1.1"
YAML_DEFAULT_USERNAME = "******"
PLATFORM_SCHEMA = vol.All(
cv.deprecated(CONF_HOST),
cv.deprecated(CONF_USERNAME),
cv.deprecated(CONF_PASSWORD),
PARENT_PLATFORM_SCHEMA.extend({
vol.Optional(CONF_HOST, default=YAML_DEFAULT_HOST):
cv.string,
vol.Optional(CONF_USERNAME, default=YAML_DEFAULT_USERNAME):
cv.string,
vol.Optional(CONF_PASSWORD):
cv.string,
}),
)
async def async_get_scanner(hass: HomeAssistant, config: ConfigType) -> None:
"""Import legacy FRITZ!Box configuration."""
SERVICE_KNX_SEND: Final = "send"
SERVICE_KNX_ATTR_PAYLOAD: Final = "payload"
SERVICE_KNX_ATTR_TYPE: Final = "type"
SERVICE_KNX_ATTR_RESPONSE: Final = "response"
SERVICE_KNX_ATTR_REMOVE: Final = "remove"
SERVICE_KNX_EVENT_REGISTER: Final = "event_register"
SERVICE_KNX_EXPOSURE_REGISTER: Final = "exposure_register"
SERVICE_KNX_READ: Final = "read"
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.All(
# deprecated since 2021.12
cv.deprecated(ConnectionSchema.CONF_KNX_STATE_UPDATER),
cv.deprecated(ConnectionSchema.CONF_KNX_RATE_LIMIT),
cv.deprecated(CONF_KNX_ROUTING),
cv.deprecated(CONF_KNX_TUNNELING),
cv.deprecated(CONF_KNX_INDIVIDUAL_ADDRESS),
cv.deprecated(ConnectionSchema.CONF_KNX_MCAST_GRP),
cv.deprecated(ConnectionSchema.CONF_KNX_MCAST_PORT),
cv.deprecated(CONF_KNX_EVENT_FILTER),
# deprecated since 2021.4
cv.deprecated("config_file"),
# deprecated since 2021.2
cv.deprecated(CONF_KNX_FIRE_EVENT),
cv.deprecated("fire_event_filter",
replacement_key=CONF_KNX_EVENT_FILTER),
vol.Schema({
**ConnectionSchema.SCHEMA,
)
from .legacy import DeviceScanner # noqa: F401 pylint: disable=unused-import
SERVICE_SEE = "see"
SOURCE_TYPES = (
SOURCE_TYPE_GPS,
SOURCE_TYPE_ROUTER,
SOURCE_TYPE_BLUETOOTH,
SOURCE_TYPE_BLUETOOTH_LE,
)
NEW_DEVICE_DEFAULTS_SCHEMA = vol.Any(
None,
vol.All(
cv.deprecated(CONF_AWAY_HIDE, invalidation_version="0.107.0"),
vol.Schema({
vol.Optional(CONF_TRACK_NEW, default=DEFAULT_TRACK_NEW):
cv.boolean,
vol.Optional(CONF_AWAY_HIDE, default=DEFAULT_AWAY_HIDE):
cv.boolean,
}),
),
)
PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({
vol.Optional(CONF_SCAN_INTERVAL):
cv.time_period,
vol.Optional(CONF_TRACK_NEW):
cv.boolean,
vol.Optional(CONF_CONSIDER_HOME, default=DEFAULT_CONSIDER_HOME):
vol.All(cv.time_period, cv.positive_timedelta),
vol.Optional(CONF_DEVICE_DECIMALS, default=DEFAULT_DEVICE_DECIMALS):
vol.In([DEFAULT_DEVICE_DECIMALS, 0, 1, 2, 3, 4]),
vol.Optional(CONF_DEVICE_USE_MEDIAN, default=DEFAULT_DEVICE_USE_MEDIAN):
vol.In([DEFAULT_DEVICE_USE_MEDIAN, True, False]),
vol.Optional(CONF_DEVICE_RESTORE_STATE,
default=DEFAULT_DEVICE_RESTORE_STATE):
vol.In([DEFAULT_DEVICE_RESTORE_STATE, True, False]),
vol.Optional(CONF_DEVICE_RESET_TIMER, default=DEFAULT_DEVICE_RESET_TIMER):
cv.positive_int,
})
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.All(
cv.deprecated(CONF_ROUNDING),
vol.Schema(
{
vol.Optional(CONF_ROUNDING, default=DEFAULT_ROUNDING):
cv.positive_int,
vol.Optional(CONF_DECIMALS, default=DEFAULT_DECIMALS):
cv.positive_int,
vol.Optional(CONF_PERIOD, default=DEFAULT_PERIOD):
cv.positive_int,
vol.Optional(CONF_LOG_SPIKES, default=DEFAULT_LOG_SPIKES):
cv.boolean,
vol.Optional(CONF_USE_MEDIAN, default=DEFAULT_USE_MEDIAN):
cv.boolean,
vol.Optional(CONF_ACTIVE_SCAN, default=DEFAULT_ACTIVE_SCAN):
cv.boolean,
vol.Optional(CONF_HCI_INTERFACE,
from .favorites import SonosFavorites
from .speaker import SonosSpeaker
_LOGGER = logging.getLogger(__name__)
CONF_ADVERTISE_ADDR = "advertise_addr"
CONF_INTERFACE_ADDR = "interface_addr"
DISCOVERY_IGNORED_MODELS = ["Sonos Boost"]
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN: vol.Schema(
{
MP_DOMAIN: vol.All(
cv.deprecated(CONF_INTERFACE_ADDR),
vol.Schema(
{
vol.Optional(CONF_ADVERTISE_ADDR): cv.string,
vol.Optional(CONF_INTERFACE_ADDR): cv.string,
vol.Optional(CONF_HOSTS): vol.All(
cv.ensure_list_csv, [cv.string]
),
}
),
)
}
)
},
extra=vol.ALLOW_EXTRA,
)
STATUS_RUNNING = 1
STATUS_STOPPED = 2
STATUS_WAIT = 3
def _has_all_unique_names_and_ports(bridges):
"""Validate that each homekit bridge configured has a unique name."""
names = [bridge[CONF_NAME] for bridge in bridges]
ports = [bridge[CONF_PORT] for bridge in bridges]
vol.Schema(vol.Unique())(names)
vol.Schema(vol.Unique())(ports)
return bridges
BRIDGE_SCHEMA = vol.All(
cv.deprecated(CONF_ZEROCONF_DEFAULT_INTERFACE),
cv.deprecated(CONF_SAFE_MODE),
vol.Schema(
{
vol.Optional(CONF_HOMEKIT_MODE, default=DEFAULT_HOMEKIT_MODE):
vol.In(HOMEKIT_MODES),
vol.Optional(CONF_NAME, default=BRIDGE_NAME):
vol.All(cv.string, vol.Length(min=3, max=25)),
vol.Optional(CONF_PORT, default=DEFAULT_PORT):
cv.port,
vol.Optional(CONF_IP_ADDRESS):
vol.All(ipaddress.ip_address, cv.string),
vol.Optional(CONF_ADVERTISE_IP):
vol.All(ipaddress.ip_address, cv.string),
vol.Optional(CONF_AUTO_START, default=DEFAULT_AUTO_START):
cv.boolean,
from homeassistant.helpers.entity import Entity, async_generate_entity_id
from homeassistant.helpers.event import async_track_state_change
_LOGGER = logging.getLogger(__name__)
SENSOR_SCHEMA = vol.Schema({
vol.Required(CONF_VALUE_TEMPLATE): cv.template,
vol.Optional(CONF_ICON_TEMPLATE): cv.template,
vol.Optional(CONF_ENTITY_PICTURE_TEMPLATE): cv.template,
vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
vol.Optional(ATTR_UNIT_OF_MEASUREMENT): cv.string,
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids
})
SENSOR_SCHEMA = vol.All(
cv.deprecated(ATTR_ENTITY_ID),
SENSOR_SCHEMA,
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_SENSORS): vol.Schema({cv.slug: SENSOR_SCHEMA}),
})
@asyncio.coroutine
# pylint: disable=unused-argument
def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Set up the template sensors."""
sensors = []
for device, device_config in config[CONF_SENSORS].items():
MAX_RETRIES = 3
MAX_CONN_RETRIES = 2
MAX_LOOP_WARN = 3
MAX_UPDATE_FAIL_ALLOWED = 10
# not stress to match cloud if multiple call
MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=10)
SMARTTHINQ_SCHEMA = vol.Schema({
vol.Required(CONF_TOKEN): str,
vol.Required(CONF_REGION): str,
vol.Required(CONF_LANGUAGE): str,
})
CONFIG_SCHEMA = vol.Schema(
vol.All(
cv.deprecated(DOMAIN),
{DOMAIN: SMARTTHINQ_SCHEMA},
),
extra=vol.ALLOW_EXTRA,
)
_LOGGER = logging.getLogger(__name__)
class LGEAuthentication:
def __init__(self, region, language, use_api_v2=True):
self._region = region
self._language = language
self._use_api_v2 = use_api_v2
def _create_client(self):
TAHOMA_DEVICE_TO_PLATFORM,
)
from .coordinator import TahomaDataUpdateCoordinator
_LOGGER = logging.getLogger(__name__)
SERVICE_EXECUTE_COMMAND = "execute_command"
HOMEKIT_SETUP_CODE = "homekit:SetupCode"
HOMEKIT_STACK = "HomekitStack"
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.All(
cv.deprecated(CONF_EXCLUDE),
vol.Schema({
vol.Required(CONF_USERNAME):
cv.string,
vol.Required(CONF_PASSWORD):
cv.string,
vol.Optional(CONF_EXCLUDE, default=[]):
vol.All(cv.ensure_list, [cv.string]),
}),
)
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(hass: HomeAssistant, config: dict):
from homeassistant.util import Throttle
from .const import (
CONF_FFMPEG_ARGUMENTS,
DATA_COORDINATOR,
DEFAULT_FFMPEG_ARGUMENTS,
DEFAULT_TIMEOUT,
DOMAIN,
MANUFACTURER,
)
from .coordinator import CanaryDataUpdateCoordinator
MIN_TIME_BETWEEN_SESSION_RENEW = timedelta(seconds=90)
PLATFORM_SCHEMA = vol.All(
cv.deprecated(CONF_FFMPEG_ARGUMENTS),
PLATFORM_SCHEMA.extend({
vol.Optional(CONF_FFMPEG_ARGUMENTS, default=DEFAULT_FFMPEG_ARGUMENTS):
cv.string
}),
)
async def async_setup_entry(
hass: HomeAssistantType,
entry: ConfigEntry,
async_add_entities: Callable[[list[Entity], bool], None],
) -> None:
"""Set up Canary sensors based on a config entry."""
coordinator: CanaryDataUpdateCoordinator = hass.data[DOMAIN][
entry.entry_id][DATA_COORDINATOR]
CONF_HOST,
CONF_USERNAME,
EVENT_HOMEASSISTANT_STOP,
)
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.discovery import async_load_platform
_LOGGER = logging.getLogger(__name__)
DOMAIN = "fortigate"
DATA_FGT = DOMAIN
CONFIG_SCHEMA = vol.Schema(
vol.All(
cv.deprecated(DOMAIN, invalidation_version="0.112.0"),
{
DOMAIN:
vol.Schema({
vol.Required(CONF_HOST):
cv.string,
vol.Required(CONF_USERNAME):
cv.string,
vol.Required(CONF_API_KEY):
cv.string,
vol.Optional(CONF_DEVICES, default=[]):
vol.All(cv.ensure_list, [cv.string]),
})
},
),
extra=vol.ALLOW_EXTRA,
cv.boolean,
vol.Optional(CONF_ZIGPY):
dict,
vol.Optional(CONF_RADIO_TYPE):
cv.enum(RadioType),
vol.Optional(CONF_USB_PATH):
cv.string,
vol.Optional(CONF_CUSTOM_QUIRKS_PATH):
cv.isdir,
}
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema(
vol.All(
cv.deprecated(CONF_USB_PATH),
cv.deprecated(CONF_BAUDRATE),
cv.deprecated(CONF_RADIO_TYPE),
ZHA_CONFIG_SCHEMA,
), ),
},
extra=vol.ALLOW_EXTRA,
)
# Zigbee definitions
CENTICELSIUS = "C-100"
# Internal definitions
_LOGGER = logging.getLogger(__name__)
_LOGGER = logging.getLogger(__name__)
_DEFAULT_TARIFF = TARIFFS[0]
VALID_POWER = vol.All(vol.Coerce(float), vol.Range(min=1.0, max=15.0))
VALID_TARIFF = vol.In(TARIFFS)
UI_CONFIG_SCHEMA = vol.Schema({
vol.Required(CONF_NAME, default=DEFAULT_NAME):
str,
vol.Required(ATTR_TARIFF, default=_DEFAULT_TARIFF):
VALID_TARIFF,
vol.Required(ATTR_POWER, default=DEFAULT_POWER_KW):
VALID_POWER,
vol.Required(ATTR_POWER_P3, default=DEFAULT_POWER_KW):
VALID_POWER,
})
CONFIG_SCHEMA = vol.Schema(
vol.All(cv.deprecated(DOMAIN), {DOMAIN: cv.ensure_list(UI_CONFIG_SCHEMA)}),
extra=vol.ALLOW_EXTRA,
)
async def async_setup(hass: HomeAssistant, config: dict) -> bool:
"""Set up the electricity price sensor from configuration.yaml."""
for conf in config.get(DOMAIN, []):
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN, data=conf, context={"source": SOURCE_IMPORT}))
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
vol.Required(CONF_NAME): cv.string,
vol.Optional(CONF_COMMAND_OFF): data_packet,
vol.Optional(CONF_COMMAND_ON): data_packet,
}
)
OLD_SWITCH_SCHEMA = vol.Schema(
{
vol.Optional(CONF_COMMAND_OFF): data_packet,
vol.Optional(CONF_COMMAND_ON): data_packet,
vol.Optional(CONF_FRIENDLY_NAME): cv.string,
}
)
PLATFORM_SCHEMA = vol.All(
cv.deprecated(CONF_HOST),
cv.deprecated(CONF_SLOTS),
cv.deprecated(CONF_TIMEOUT),
cv.deprecated(CONF_TYPE),
PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_MAC): mac_address,
vol.Optional(CONF_HOST): cv.string,
vol.Optional(CONF_SWITCHES, default=[]): vol.Any(
cv.schema_with_slug_keys(OLD_SWITCH_SCHEMA),
vol.All(cv.ensure_list, [SWITCH_SCHEMA]),
),
}
),
)
from .coordinator import ToonDataUpdateCoordinator
from .oauth2 import register_oauth2_implementations
PLATFORMS = {
BINARY_SENSOR_DOMAIN,
CLIMATE_DOMAIN,
SENSOR_DOMAIN,
SWITCH_DOMAIN,
}
# Validation of the user's configuration
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.All(
cv.deprecated(CONF_SCAN_INTERVAL),
vol.Schema(
{
vol.Required(CONF_CLIENT_ID):
cv.string,
vol.Required(CONF_CLIENT_SECRET):
cv.string,
vol.Optional(CONF_SCAN_INTERVAL,
default=DEFAULT_SCAN_INTERVAL):
cv.positive_time_period,
}),
)
},
extra=vol.ALLOW_EXTRA,
)
from .const import (
CALL_TYPE_COIL,
CALL_TYPE_DISCRETE,
CONF_ADDRESS,
CONF_COILS,
CONF_HUB,
CONF_INPUT_TYPE,
CONF_INPUTS,
DEFAULT_HUB,
MODBUS_DOMAIN,
)
_LOGGER = logging.getLogger(__name__)
PLATFORM_SCHEMA = vol.All(
cv.deprecated(CONF_COILS, CONF_INPUTS),
PLATFORM_SCHEMA.extend({
vol.Required(CONF_INPUTS): [
vol.All(
cv.deprecated(CALL_TYPE_COIL, CONF_ADDRESS),
vol.Schema({
vol.Required(CONF_ADDRESS):
cv.positive_int,
vol.Required(CONF_NAME):
cv.string,
vol.Optional(CONF_DEVICE_CLASS):
DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_HUB, default=DEFAULT_HUB):
cv.string,
vol.Optional(CONF_SLAVE):
cv.positive_int,
CONF_DEV_ID,
CONF_HEAT_AWAY_TEMPERATURE,
CONF_LOC_ID,
DEFAULT_COOL_AWAY_TEMPERATURE,
DEFAULT_HEAT_AWAY_TEMPERATURE,
DOMAIN,
)
ATTR_FAN_ACTION = "fan_action"
ATTR_PERMANENT_HOLD = "permanent_hold"
PRESET_HOLD = "Hold"
PLATFORM_SCHEMA = vol.All(
cv.deprecated(CONF_REGION),
PLATFORM_SCHEMA.extend({
vol.Required(CONF_USERNAME):
cv.string,
vol.Required(CONF_PASSWORD):
cv.string,
vol.Optional(CONF_COOL_AWAY_TEMPERATURE,
default=DEFAULT_COOL_AWAY_TEMPERATURE):
vol.Coerce(int),
vol.Optional(CONF_HEAT_AWAY_TEMPERATURE,
default=DEFAULT_HEAT_AWAY_TEMPERATURE):
vol.Coerce(int),
vol.Optional(CONF_REGION):
cv.string,
vol.Optional(CONF_DEV_ID):
cv.string,
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from .const import DOMAIN, PLATFORMS
CONFIG_SCHEMA = cv.deprecated(DOMAIN)
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
CONF_KNX_STATE_UPDATER = "state_updater"
CONF_KNX_RATE_LIMIT = "rate_limit"
CONF_KNX_EXPOSE = "expose"
SERVICE_KNX_SEND = "send"
SERVICE_KNX_ATTR_ADDRESS = "address"
SERVICE_KNX_ATTR_PAYLOAD = "payload"
SERVICE_KNX_ATTR_TYPE = "type"
SERVICE_KNX_ATTR_REMOVE = "remove"
SERVICE_KNX_EVENT_REGISTER = "event_register"
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.All(
cv.deprecated(CONF_KNX_FIRE_EVENT),
cv.deprecated("fire_event_filter",
replacement_key=CONF_KNX_EVENT_FILTER),
vol.Schema({
vol.Optional(CONF_KNX_CONFIG):
cv.string,
vol.Exclusive(CONF_KNX_ROUTING, "connection_type"):
ConnectionSchema.ROUTING_SCHEMA,
vol.Exclusive(CONF_KNX_TUNNELING, "connection_type"):
ConnectionSchema.TUNNELING_SCHEMA,
vol.Optional(CONF_KNX_FIRE_EVENT):
cv.boolean,
vol.Optional(CONF_KNX_EVENT_FILTER, default=[]):
vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_KNX_INDIVIDUAL_ADDRESS,
default=XKNX.DEFAULT_ADDRESS):
vol.Exclusive(CONF_VALUE_TEMPLATE,
CONF_VALUE_OR_POSITION_TEMPLATE): cv.template,
vol.Optional(CONF_POSITION_TEMPLATE): cv.template,
vol.Optional(CONF_TILT_TEMPLATE): cv.template,
vol.Optional(CONF_ICON_TEMPLATE): cv.template,
vol.Optional(CONF_ENTITY_PICTURE_TEMPLATE): cv.template,
vol.Optional(CONF_OPTIMISTIC): cv.boolean,
vol.Optional(CONF_TILT_OPTIMISTIC): cv.boolean,
vol.Optional(POSITION_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(TILT_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_FRIENDLY_NAME): cv.string,
vol.Optional(CONF_ENTITY_ID): cv.entity_ids
})
COVER_SCHEMA = vol.All(
cv.deprecated(CONF_ENTITY_ID),
COVER_SCHEMA,
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_COVERS): vol.Schema({cv.slug: COVER_SCHEMA}),
})
@asyncio.coroutine
def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
"""Set up the Template cover."""
covers = []
for device, device_config in config[CONF_COVERS].items():
friendly_name = device_config.get(CONF_FRIENDLY_NAME, device)
DATA_KEY = 'tplink_lte'
CONF_NOTIFY = 'notify'
# Deprecated in 0.88.0, invalidated in 0.91.0, remove in 0.92.0
ATTR_TARGET_INVALIDATION_VERSION = '0.91.0'
_NOTIFY_SCHEMA = vol.All(
vol.Schema({
vol.Optional(CONF_NAME): cv.string,
vol.Optional(ATTR_TARGET): vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_RECIPIENT): vol.All(cv.ensure_list, [cv.string])
}),
cv.deprecated(
ATTR_TARGET,
replacement_key=CONF_RECIPIENT,
invalidation_version=ATTR_TARGET_INVALIDATION_VERSION
),
cv.has_at_least_one_key(CONF_RECIPIENT),
)
CONFIG_SCHEMA = vol.Schema({
DOMAIN: vol.All(cv.ensure_list, [vol.Schema({
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_PASSWORD): cv.string,
vol.Optional(CONF_NOTIFY): vol.All(cv.ensure_list, [_NOTIFY_SCHEMA]),
})])
}, extra=vol.ALLOW_EXTRA)
@attr.s
STATUS_DELIVERED = 'delivered'
SCAN_INTERVAL = timedelta(seconds=1800)
PLATFORM_SCHEMA = vol.All(
PLATFORM_SCHEMA.extend({
vol.Required(CONF_USERNAME): cv.string,
vol.Required(CONF_PASSWORD): cv.string,
vol.Optional(CONF_NAME): cv.string,
vol.Optional(CONF_UPDATE_INTERVAL):
vol.All(cv.time_period, cv.positive_timedelta),
}),
cv.deprecated(
CONF_UPDATE_INTERVAL,
replacement_key=CONF_SCAN_INTERVAL,
invalidation_version=CONF_UPDATE_INTERVAL_INVALIDATION_VERSION,
default=SCAN_INTERVAL
)
)
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Fedex platform."""
import fedexdeliverymanager
name = config.get(CONF_NAME)
update_interval = config.get(CONF_SCAN_INTERVAL, SCAN_INTERVAL)
try:
cookie = hass.config.path(COOKIE)
session = fedexdeliverymanager.get_session(
cv.time_period, lambda value: value.seconds, vol.Range(max=255)
),
vol.Optional(ATTR_EXIT_DELAY_AWAY): vol.All(
cv.time_period, lambda value: value.seconds, vol.Range(min=45, max=255)
),
vol.Optional(ATTR_EXIT_DELAY_HOME): vol.All(
cv.time_period, lambda value: value.seconds, vol.Range(max=255)
),
vol.Optional(ATTR_LIGHT): cv.boolean,
vol.Optional(ATTR_VOICE_PROMPT_VOLUME): vol.All(
vol.Coerce(int), vol.In(VOLUMES)
),
}
)
CONFIG_SCHEMA = cv.deprecated(DOMAIN, invalidation_version="0.119")
@callback
def _async_save_refresh_token(hass, config_entry, token):
"""Save a refresh token to the config entry."""
hass.config_entries.async_update_entry(
config_entry, data={**config_entry.data, CONF_TOKEN: token}
)
async def async_get_client_id(hass):
"""Get a client ID (based on the HASS unique ID) for the SimpliSafe API.
Note that SimpliSafe requires full, "dashed" versions of UUIDs.
"""
class ClimateSchema:
"""Voluptuous schema for KNX climate devices."""
CONF_SETPOINT_SHIFT_ADDRESS = "setpoint_shift_address"
CONF_SETPOINT_SHIFT_STATE_ADDRESS = "setpoint_shift_state_address"
CONF_SETPOINT_SHIFT_MODE = "setpoint_shift_mode"
CONF_SETPOINT_SHIFT_MAX = "setpoint_shift_max"
CONF_SETPOINT_SHIFT_MIN = "setpoint_shift_min"
CONF_TEMPERATURE_ADDRESS = "temperature_address"
CONF_TEMPERATURE_STEP = "temperature_step"
CONF_TARGET_TEMPERATURE_ADDRESS = "target_temperature_address"
CONF_TARGET_TEMPERATURE_STATE_ADDRESS = "target_temperature_state_address"
CONF_OPERATION_MODE_ADDRESS = "operation_mode_address"
CONF_OPERATION_MODE_STATE_ADDRESS = "operation_mode_state_address"
CONF_CONTROLLER_STATUS_ADDRESS = "controller_status_address"
CONF_CONTROLLER_STATUS_STATE_ADDRESS = "controller_status_state_address"
CONF_CONTROLLER_MODE_ADDRESS = "controller_mode_address"
CONF_CONTROLLER_MODE_STATE_ADDRESS = "controller_mode_state_address"
CONF_HEAT_COOL_ADDRESS = "heat_cool_address"
CONF_HEAT_COOL_STATE_ADDRESS = "heat_cool_state_address"
CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS = (
"operation_mode_frost_protection_address")
CONF_OPERATION_MODE_NIGHT_ADDRESS = "operation_mode_night_address"
CONF_OPERATION_MODE_COMFORT_ADDRESS = "operation_mode_comfort_address"
CONF_OPERATION_MODE_STANDBY_ADDRESS = "operation_mode_standby_address"
CONF_OPERATION_MODES = "operation_modes"
CONF_CONTROLLER_MODES = "controller_modes"
CONF_ON_OFF_ADDRESS = "on_off_address"
CONF_ON_OFF_STATE_ADDRESS = "on_off_state_address"
CONF_ON_OFF_INVERT = "on_off_invert"
CONF_MIN_TEMP = "min_temp"
CONF_MAX_TEMP = "max_temp"
DEFAULT_NAME = "KNX Climate"
DEFAULT_SETPOINT_SHIFT_MODE = "DPT6010"
DEFAULT_SETPOINT_SHIFT_MAX = 6
DEFAULT_SETPOINT_SHIFT_MIN = -6
DEFAULT_TEMPERATURE_STEP = 0.1
DEFAULT_ON_OFF_INVERT = False
SCHEMA = vol.All(
cv.deprecated("setpoint_shift_step",
replacement_key=CONF_TEMPERATURE_STEP),
vol.Schema({
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_SETPOINT_SHIFT_MODE,
default=DEFAULT_SETPOINT_SHIFT_MODE):
cv.enum(SetpointShiftMode),
vol.Optional(CONF_SETPOINT_SHIFT_MAX,
default=DEFAULT_SETPOINT_SHIFT_MAX):
vol.All(int, vol.Range(min=0, max=32)),
vol.Optional(CONF_SETPOINT_SHIFT_MIN,
default=DEFAULT_SETPOINT_SHIFT_MIN):
vol.All(int, vol.Range(min=-32, max=0)),
vol.Optional(CONF_TEMPERATURE_STEP,
default=DEFAULT_TEMPERATURE_STEP):
vol.All(float, vol.Range(min=0, max=2)),
vol.Required(CONF_TEMPERATURE_ADDRESS):
cv.string,
vol.Required(CONF_TARGET_TEMPERATURE_STATE_ADDRESS):
cv.string,
vol.Optional(CONF_TARGET_TEMPERATURE_ADDRESS):
cv.string,
vol.Optional(CONF_SETPOINT_SHIFT_ADDRESS):
cv.string,
vol.Optional(CONF_SETPOINT_SHIFT_STATE_ADDRESS):
cv.string,
vol.Optional(CONF_OPERATION_MODE_ADDRESS):
cv.string,
vol.Optional(CONF_OPERATION_MODE_STATE_ADDRESS):
cv.string,
vol.Optional(CONF_CONTROLLER_STATUS_ADDRESS):
cv.string,
vol.Optional(CONF_CONTROLLER_STATUS_STATE_ADDRESS):
cv.string,
vol.Optional(CONF_CONTROLLER_MODE_ADDRESS):
cv.string,
vol.Optional(CONF_CONTROLLER_MODE_STATE_ADDRESS):
cv.string,
vol.Optional(CONF_HEAT_COOL_ADDRESS):
cv.string,
vol.Optional(CONF_HEAT_COOL_STATE_ADDRESS):
cv.string,
vol.Optional(CONF_OPERATION_MODE_FROST_PROTECTION_ADDRESS):
cv.string,
vol.Optional(CONF_OPERATION_MODE_NIGHT_ADDRESS):
cv.string,
vol.Optional(CONF_OPERATION_MODE_COMFORT_ADDRESS):
cv.string,
vol.Optional(CONF_OPERATION_MODE_STANDBY_ADDRESS):
cv.string,
vol.Optional(CONF_ON_OFF_ADDRESS):
cv.string,
vol.Optional(CONF_ON_OFF_STATE_ADDRESS):
cv.string,
vol.Optional(CONF_ON_OFF_INVERT, default=DEFAULT_ON_OFF_INVERT):
cv.boolean,
vol.Optional(CONF_OPERATION_MODES):
vol.All(cv.ensure_list, [vol.In({**PRESET_MODES})]),
vol.Optional(CONF_CONTROLLER_MODES):
vol.All(cv.ensure_list, [vol.In({**CONTROLLER_MODES})]),
vol.Optional(CONF_MIN_TEMP):
vol.Coerce(float),
vol.Optional(CONF_MAX_TEMP):
vol.Coerce(float),
}),
)
)
from .const import EVENT_COMMAND_RECEIVED, EVENT_SYNC_RECEIVED # noqa: F401
from .const import EVENT_QUERY_RECEIVED # noqa: F401
from .http import async_register_http
_LOGGER = logging.getLogger(__name__)
ENTITY_SCHEMA = vol.Schema({
vol.Optional(CONF_NAME): cv.string,
vol.Optional(CONF_EXPOSE): cv.boolean,
vol.Optional(CONF_ALIASES): vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_ROOM_HINT): cv.string,
})
GOOGLE_ASSISTANT_SCHEMA = vol.All(
cv.deprecated(CONF_ALLOW_UNLOCK, invalidation_version='0.95'),
vol.Schema({
vol.Required(CONF_PROJECT_ID): cv.string,
vol.Optional(CONF_EXPOSE_BY_DEFAULT,
default=DEFAULT_EXPOSE_BY_DEFAULT): cv.boolean,
vol.Optional(CONF_EXPOSED_DOMAINS,
default=DEFAULT_EXPOSED_DOMAINS): cv.ensure_list,
vol.Optional(CONF_API_KEY): cv.string,
vol.Optional(CONF_ENTITY_CONFIG): {cv.entity_id: ENTITY_SCHEMA},
vol.Optional(CONF_ALLOW_UNLOCK): cv.boolean,
# str on purpose, makes sure it is configured correctly.
vol.Optional(CONF_SECURE_DEVICES_PIN): str,
}, extra=vol.PREVENT_EXTRA))
CONFIG_SCHEMA = vol.Schema({
DOMAIN: GOOGLE_ASSISTANT_SCHEMA
"zone",
vol.Schema({vol.Optional("zone", default={}): {vol.Optional("hello"): 1}}),
"dict",
),
(
"zone",
vol.Schema(
{vol.Optional("zone", default=dict): {vol.Optional("hello"): 1}}
),
"dict",
),
("zone", vol.Schema({vol.Optional("zone"): int}), None),
("zone", vol.Schema({"zone": int}), None),
(
"not_existing",
vol.Schema({vol.Optional("zone", default=dict): dict}),
None,
),
("non_existing", vol.Schema({"zone": int}), None),
("zone", vol.Schema({}), None),
("plex", vol.Schema(vol.All({"plex": {"host": str}})), "dict"),
("openuv", cv.deprecated("openuv"), None),
],
)
def test_identify_config_schema(domain, schema, expected):
"""Test identify config schema."""
assert (
config_util._identify_config_schema(Mock(DOMAIN=domain, CONFIG_SCHEMA=schema))
== expected
)
MQTT_AVAILABILITY_SCHEMA = MQTT_AVAILABILITY_SINGLE_SCHEMA.extend(
MQTT_AVAILABILITY_LIST_SCHEMA.schema)
def validate_device_has_at_least_one_identifier(
value: ConfigType) -> ConfigType:
"""Validate that a device info entry has at least one identifying value."""
if value.get(CONF_IDENTIFIERS) or value.get(CONF_CONNECTIONS):
return value
raise vol.Invalid("Device must have at least one identifying value in "
"'identifiers' and/or 'connections'")
MQTT_ENTITY_DEVICE_INFO_SCHEMA = vol.All(
cv.deprecated(CONF_DEPRECATED_VIA_HUB, CONF_VIA_DEVICE),
vol.Schema({
vol.Optional(CONF_IDENTIFIERS, default=list):
vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_CONNECTIONS, default=list):
vol.All(cv.ensure_list, [vol.All(vol.Length(2), [cv.string])]),
vol.Optional(CONF_MANUFACTURER):
cv.string,
vol.Optional(CONF_MODEL):
cv.string,
vol.Optional(CONF_NAME):
cv.string,
vol.Optional(CONF_SW_VERSION):
cv.string,
vol.Optional(CONF_VIA_DEVICE):
cv.string,
SRV_PRINT_IM_ALDB = 'print_im_all_link_database'
SRV_X10_ALL_UNITS_OFF = 'x10_all_units_off'
SRV_X10_ALL_LIGHTS_OFF = 'x10_all_lights_off'
SRV_X10_ALL_LIGHTS_ON = 'x10_all_lights_on'
SRV_ALL_LINK_GROUP = 'group'
SRV_ALL_LINK_MODE = 'mode'
SRV_LOAD_DB_RELOAD = 'reload'
SRV_CONTROLLER = 'controller'
SRV_RESPONDER = 'responder'
SRV_HOUSECODE = 'housecode'
HOUSECODES = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p']
CONF_DEVICE_OVERRIDE_SCHEMA = vol.All(
cv.deprecated(CONF_PLATFORM), vol.Schema({
vol.Required(CONF_ADDRESS): cv.string,
vol.Optional(CONF_CAT): cv.byte,
vol.Optional(CONF_SUBCAT): cv.byte,
vol.Optional(CONF_FIRMWARE): cv.byte,
vol.Optional(CONF_PRODUCT_KEY): cv.byte,
vol.Optional(CONF_PLATFORM): cv.string,
}))
CONF_X10_SCHEMA = vol.All(
vol.Schema({
vol.Required(CONF_HOUSECODE): cv.string,
vol.Required(CONF_UNITCODE): vol.Range(min=1, max=16),
vol.Required(CONF_PLATFORM): cv.string,
vol.Optional(CONF_DIM_STEPS): vol.Range(min=2, max=255)
}))
CONF_RETRY_QUEUE = 'retry_queue_limit'
DEFAULT_DATABASE = 'home_assistant'
DEFAULT_VERIFY_SSL = True
DOMAIN = 'influxdb'
TIMEOUT = 5
RETRY_DELAY = 20
QUEUE_BACKLOG_SECONDS = 10
COMPONENT_CONFIG_SCHEMA_ENTRY = vol.Schema({
vol.Optional(CONF_OVERRIDE_MEASUREMENT): cv.string,
})
CONFIG_SCHEMA = vol.Schema({
DOMAIN: vol.All(cv.deprecated(CONF_RETRY_QUEUE), vol.Schema({
vol.Optional(CONF_HOST): cv.string,
vol.Inclusive(CONF_USERNAME, 'authentication'): cv.string,
vol.Inclusive(CONF_PASSWORD, 'authentication'): cv.string,
vol.Optional(CONF_EXCLUDE, default={}): vol.Schema({
vol.Optional(CONF_ENTITIES, default=[]): cv.entity_ids,
vol.Optional(CONF_DOMAINS, default=[]):
vol.All(cv.ensure_list, [cv.string])
}),
vol.Optional(CONF_INCLUDE, default={}): vol.Schema({
vol.Optional(CONF_ENTITIES, default=[]): cv.entity_ids,
vol.Optional(CONF_DOMAINS, default=[]):
vol.All(cv.ensure_list, [cv.string])
}),
vol.Optional(CONF_DB_NAME, default=DEFAULT_DATABASE): cv.string,
vol.Optional(CONF_PORT): cv.port,
