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),
vol.Inclusive(CONF_CLIENT_KEY,
"client_key_auth",
msg=CLIENT_KEY_AUTH_MSG):
cv.isfile,
vol.Inclusive(CONF_CLIENT_CERT,
"client_key_auth",
msg=CLIENT_KEY_AUTH_MSG):
cv.isfile,
vol.Optional(CONF_TLS_INSECURE):
cv.boolean,
vol.Optional(CONF_TLS_VERSION, default=DEFAULT_TLS_PROTOCOL):
vol.Any("auto", "1.0", "1.1", "1.2"),
vol.Optional(CONF_PROTOCOL, default=DEFAULT_PROTOCOL):
vol.All(cv.string, vol.In([PROTOCOL_31, PROTOCOL_311])),
vol.Optional(CONF_EMBEDDED):
vol.All(server.HBMQTT_CONFIG_SCHEMA, embedded_broker_deprecated),
vol.Optional(CONF_WILL_MESSAGE):
ALERTS_ATTRS = [
"time", "description", "expires", "severity", "uri", "regions", "title"
]
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_MONITORED_CONDITIONS):
vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
vol.Required(CONF_API_KEY):
cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_UNITS):
vol.In(ALLOWED_UNITS),
vol.Optional(CONF_LANGUAGE, default=DEFAULT_LANGUAGE):
vol.In(LANGUAGE_CODES),
vol.Inclusive(CONF_LATITUDE, "coordinates", "Latitude and longitude must exist together"):
cv.latitude,
vol.Inclusive(CONF_LONGITUDE, "coordinates", "Latitude and longitude must exist together"):
cv.longitude,
vol.Optional(CONF_FORECAST):
vol.All(cv.ensure_list, [vol.Range(min=0, max=7)]),
vol.Optional(CONF_HOURLY_FORECAST):
vol.All(cv.ensure_list, [vol.Range(min=0, max=48)]),
})
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Dark Sky sensor."""
latitude = config.get(CONF_LATITUDE, hass.config.latitude)
longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
language = config.get(CONF_LANGUAGE)
}
DEFAULT_VOICE = 'Joanna'
DEFAULT_OUTPUT_FORMAT = 'mp3'
DEFAULT_TEXT_TYPE = 'text'
DEFAULT_SAMPLE_RATES = {
'mp3': '22050',
'ogg_vorbis': '22050',
'pcm': '16000',
}
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_REGION, default=DEFAULT_REGION):
vol.In(SUPPORTED_REGIONS),
vol.Inclusive(CONF_ACCESS_KEY_ID, ATTR_CREDENTIALS):
cv.string,
vol.Inclusive(CONF_SECRET_ACCESS_KEY, ATTR_CREDENTIALS):
cv.string,
vol.Exclusive(CONF_PROFILE_NAME, ATTR_CREDENTIALS):
cv.string,
vol.Optional(CONF_VOICE, default=DEFAULT_VOICE):
vol.In(SUPPORTED_VOICES),
vol.Optional(CONF_OUTPUT_FORMAT, default=DEFAULT_OUTPUT_FORMAT):
vol.In(SUPPORTED_OUTPUT_FORMATS),
vol.Optional(CONF_SAMPLE_RATE):
vol.All(cv.string, vol.In(SUPPORTED_SAMPLE_RATES)),
vol.Optional(CONF_TEXT_TYPE, default=DEFAULT_TEXT_TYPE):
vol.In(SUPPORTED_TEXT_TYPES),
})
DOCKER_PORTS_DESCRIPTION = vol.Schema({
vol.All(vol.Coerce(str), vol.Match(r"^\d+(?:/tcp|/udp)?$")):
vol.Coerce(str)
})
# pylint: disable=no-value-for-parameter
SCHEMA_HASS_CONFIG = vol.Schema(
{
vol.Optional(ATTR_UUID, default=lambda: uuid.uuid4().hex):
UUID_MATCH,
vol.Optional(ATTR_ACCESS_TOKEN):
TOKEN,
vol.Optional(ATTR_BOOT, default=True):
vol.Boolean(),
vol.Inclusive(ATTR_IMAGE, "custom_hass"):
DOCKER_IMAGE,
vol.Inclusive(ATTR_LAST_VERSION, "custom_hass"):
vol.Coerce(str),
vol.Optional(ATTR_PORT, default=8123):
NETWORK_PORT,
vol.Optional(ATTR_PASSWORD):
vol.Maybe(vol.Coerce(str)),
vol.Optional(ATTR_REFRESH_TOKEN):
vol.Maybe(vol.Coerce(str)),
vol.Optional(ATTR_SSL, default=False):
vol.Boolean(),
vol.Optional(ATTR_WATCHDOG, default=True):
vol.Boolean(),
vol.Optional(ATTR_WAIT_BOOT, default=600):
vol.All(vol.Coerce(int), vol.Range(min=60)),
"wind_spd_kt": ["Wind Speed kt", "kt"],
}
def validate_station(station):
"""Check that the station ID is well-formed."""
if station is None:
return
station = station.replace(".shtml", "")
if not re.fullmatch(r"ID[A-Z]\d\d\d\d\d\.\d\d\d\d\d", station):
raise vol.error.Invalid("Malformed station ID")
return station
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Inclusive(CONF_ZONE_ID, "Deprecated partial station ID"):
cv.string,
vol.Inclusive(CONF_WMO_ID, "Deprecated partial station ID"):
cv.string,
vol.Optional(CONF_NAME):
cv.string,
vol.Optional(CONF_STATION):
validate_station,
vol.Required(CONF_MONITORED_CONDITIONS, default=[]):
vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
})
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the BOM sensor."""
station = config.get(CONF_STATION)
cv.positive_int,
vol.Exclusive(EVENT_IN_WEEKS, EVENT_TYPES_CONF):
cv.positive_int,
})
ADD_EVENT_SERVICE_SCHEMA = vol.All(
cv.has_at_least_one_key(EVENT_START_DATE, EVENT_START_DATETIME, EVENT_IN),
cv.has_at_most_one_key(EVENT_START_DATE, EVENT_START_DATETIME, EVENT_IN),
{
vol.Required(EVENT_CALENDAR_ID):
cv.string,
vol.Required(EVENT_SUMMARY):
cv.string,
vol.Optional(EVENT_DESCRIPTION, default=""):
cv.string,
vol.Inclusive(EVENT_START_DATE, "dates", "Start and end dates must both be specified"):
cv.date,
vol.Inclusive(EVENT_END_DATE, "dates", "Start and end dates must both be specified"):
cv.date,
vol.Inclusive(
EVENT_START_DATETIME,
"datetimes",
"Start and end datetimes must both be specified",
):
cv.datetime,
vol.Inclusive(
EVENT_END_DATETIME,
"datetimes",
"Start and end datetimes must both be specified",
):
cv.datetime,
_LOGGER = logging.getLogger(__name__)
CONF_CALENDARS = 'calendars'
CONF_CUSTOM_CALENDARS = 'custom_calendars'
CONF_CALENDAR = 'calendar'
CONF_SEARCH = 'search'
OFFSET = '!!'
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
# pylint: disable=no-value-for-parameter
vol.Required(CONF_URL):
vol.Url(),
vol.Optional(CONF_CALENDARS, default=[]):
vol.All(cv.ensure_list, [cv.string]),
vol.Inclusive(CONF_USERNAME, 'authentication'):
cv.string,
vol.Inclusive(CONF_PASSWORD, 'authentication'):
cv.string,
vol.Optional(CONF_CUSTOM_CALENDARS, default=[]):
vol.All(cv.ensure_list, [
vol.Schema({
vol.Required(CONF_CALENDAR): cv.string,
vol.Required(CONF_NAME): cv.string,
vol.Required(CONF_SEARCH): cv.string,
})
]),
vol.Optional(CONF_VERIFY_SSL, default=True):
cv.boolean
})
vol.All(vol.Coerce(int), vol.Range(min=-1)),
}),
cv.has_at_least_one_key(CONF_PIN, CONF_ZONE),
)
DEVICE_SCHEMA_YAML = vol.All(
vol.Schema({
vol.Required(CONF_ID):
cv.matches_regex("[0-9a-f]{12}"),
vol.Optional(CONF_BINARY_SENSORS):
vol.All(cv.ensure_list, [BINARY_SENSOR_SCHEMA_YAML]),
vol.Optional(CONF_SENSORS):
vol.All(cv.ensure_list, [SENSOR_SCHEMA_YAML]),
vol.Optional(CONF_SWITCHES):
vol.All(cv.ensure_list, [SWITCH_SCHEMA_YAML]),
vol.Inclusive(CONF_HOST, "host_info"):
cv.string,
vol.Inclusive(CONF_PORT, "host_info"):
cv.port,
vol.Optional(CONF_BLINK, default=True):
cv.boolean,
vol.Optional(CONF_API_HOST, default=""):
vol.Any("", cv.url),
vol.Optional(CONF_DISCOVERY, default=True):
cv.boolean,
}),
import_device_validator,
)
# pylint: disable=no-value-for-parameter
CONFIG_SCHEMA = vol.Schema(
DEFAULT_MINIMUM_MAGNITUDE,
DEFAULT_MMI,
DEFAULT_RADIUS,
DEFAULT_SCAN_INTERVAL,
DOMAIN,
FEED,
PLATFORMS,
)
_LOGGER = logging.getLogger(__name__)
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN: vol.Schema(
{
vol.Inclusive(CONF_LATITUDE, "coordinates"): cv.latitude,
vol.Inclusive(CONF_LONGITUDE, "coordinates"): cv.longitude,
vol.Optional(CONF_MMI, default=DEFAULT_MMI): vol.All(
vol.Coerce(int), vol.Range(min=-1, max=8)
),
vol.Optional(CONF_RADIUS, default=DEFAULT_RADIUS): vol.Coerce(float),
vol.Optional(
CONF_MINIMUM_MAGNITUDE, default=DEFAULT_MINIMUM_MAGNITUDE
): cv.positive_float,
vol.Optional(
CONF_SCAN_INTERVAL, default=DEFAULT_SCAN_INTERVAL
): cv.time_period,
}
)
},
extra=vol.ALLOW_EXTRA,
ROUTING_SCHEMA = vol.Schema({
vol.Required(CONF_KNX_LOCAL_IP): cv.string,
})
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema({
vol.Optional(CONF_KNX_CONFIG):
cv.string,
vol.Exclusive(CONF_KNX_ROUTING, 'connection_type'):
ROUTING_SCHEMA,
vol.Exclusive(CONF_KNX_TUNNELING, 'connection_type'):
TUNNELING_SCHEMA,
vol.Inclusive(CONF_KNX_FIRE_EVENT, 'fire_ev'):
cv.boolean,
vol.Inclusive(CONF_KNX_FIRE_EVENT_FILTER, 'fire_ev'):
vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_KNX_STATE_UPDATER, default=True):
cv.boolean,
})
},
extra=vol.ALLOW_EXTRA)
SERVICE_KNX_SEND_SCHEMA = vol.Schema({
vol.Required(SERVICE_KNX_ATTR_ADDRESS):
cv.string,
vol.Required(SERVICE_KNX_ATTR_PAYLOAD):
vol.Any(cv.positive_int, [cv.positive_int]),
})
'wind_speed': ['Wind Speed', 'mph'],
'wind_direction': ['Wind Direction', None],
'wind_gust': ['Wind Gust', 'mph'],
'visibility': ['Visibility', None],
'visibility_distance': ['Visibility Distance', 'km'],
'uv': ['UV', None],
'precipitation': ['Probability of Precipitation', '%'],
'humidity': ['Humidity', '%']
}
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_API_KEY): cv.string,
vol.Required(CONF_MONITORED_CONDITIONS, default=[]):
vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Inclusive(CONF_LATITUDE, 'coordinates',
'Latitude and longitude must exist together'): cv.latitude,
vol.Inclusive(CONF_LONGITUDE, 'coordinates',
'Latitude and longitude must exist together'): cv.longitude,
})
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Met Office sensor platform."""
import datapoint as dp
api_key = config.get(CONF_API_KEY)
latitude = config.get(CONF_LATITUDE, hass.config.latitude)
longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
name = config.get(CONF_NAME)
datapoint = dp.connection(api_key=api_key)
ENTITY_ID_FORMAT = DOMAIN + ".{}"
SCAN_INTERVAL = timedelta(seconds=60)
CONVERTIBLE_ATTRIBUTE = [
ATTR_TEMPERATURE, ATTR_TARGET_TEMP_LOW, ATTR_TARGET_TEMP_HIGH
]
_LOGGER = logging.getLogger(__name__)
SET_TEMPERATURE_SCHEMA = vol.All(
cv.has_at_least_one_key(ATTR_TEMPERATURE, ATTR_TARGET_TEMP_HIGH,
ATTR_TARGET_TEMP_LOW),
make_entity_service_schema({
vol.Exclusive(ATTR_TEMPERATURE, "temperature"):
vol.Coerce(float),
vol.Inclusive(ATTR_TARGET_TEMP_HIGH, "temperature"):
vol.Coerce(float),
vol.Inclusive(ATTR_TARGET_TEMP_LOW, "temperature"):
vol.Coerce(float),
vol.Optional(ATTR_HVAC_MODE):
vol.In(HVAC_MODES),
}),
)
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up climate entities."""
component = hass.data[DOMAIN] = EntityComponent(_LOGGER, DOMAIN, hass,
SCAN_INTERVAL)
await component.async_setup(config)
ATTR_BOOT, ATTR_PORT, ATTR_PASSWORD, ATTR_SSL,
ATTR_WATCHDOG, ATTR_CPU_PERCENT, ATTR_MEMORY_USAGE,
ATTR_MEMORY_LIMIT, ATTR_NETWORK_RX, ATTR_NETWORK_TX,
ATTR_BLK_READ, ATTR_BLK_WRITE, ATTR_WAIT_BOOT,
ATTR_MACHINE, ATTR_REFRESH_TOKEN, CONTENT_TYPE_BINARY)
from ..coresys import CoreSysAttributes
from ..validate import NETWORK_PORT, DOCKER_IMAGE
from ..exceptions import APIError
_LOGGER = logging.getLogger(__name__)
# pylint: disable=no-value-for-parameter
SCHEMA_OPTIONS = vol.Schema({
vol.Optional(ATTR_BOOT):
vol.Boolean(),
vol.Inclusive(ATTR_IMAGE, 'custom_hass'):
vol.Maybe(vol.Coerce(str)),
vol.Inclusive(ATTR_LAST_VERSION, 'custom_hass'):
vol.Any(None, DOCKER_IMAGE),
vol.Optional(ATTR_PORT):
NETWORK_PORT,
vol.Optional(ATTR_PASSWORD):
vol.Maybe(vol.Coerce(str)),
vol.Optional(ATTR_SSL):
vol.Boolean(),
vol.Optional(ATTR_WATCHDOG):
vol.Boolean(),
vol.Optional(ATTR_WAIT_BOOT):
vol.All(vol.Coerce(int), vol.Range(min=60)),
vol.Optional(ATTR_REFRESH_TOKEN):
vol.Maybe(vol.Coerce(str)),
SUPPORT_KODI = SUPPORT_PAUSE | SUPPORT_VOLUME_SET | SUPPORT_VOLUME_MUTE | \
SUPPORT_PREVIOUS_TRACK | SUPPORT_NEXT_TRACK | SUPPORT_SEEK | \
SUPPORT_PLAY_MEDIA | SUPPORT_STOP | SUPPORT_SHUFFLE_SET | \
SUPPORT_PLAY | SUPPORT_VOLUME_STEP
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
vol.Optional(CONF_TCP_PORT, default=DEFAULT_TCP_PORT): cv.port,
vol.Optional(CONF_PROXY_SSL, default=DEFAULT_PROXY_SSL): cv.boolean,
vol.Optional(CONF_TURN_ON_ACTION, default=None): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_TURN_OFF_ACTION):
vol.Any(cv.SCRIPT_SCHEMA, vol.In(DEPRECATED_TURN_OFF_ACTIONS)),
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
vol.Inclusive(CONF_USERNAME, 'auth'): cv.string,
vol.Inclusive(CONF_PASSWORD, 'auth'): cv.string,
vol.Optional(CONF_ENABLE_WEBSOCKET, default=DEFAULT_ENABLE_WEBSOCKET):
cv.boolean,
})
SERVICE_ADD_MEDIA = 'kodi_add_to_playlist'
SERVICE_CALL_METHOD = 'kodi_call_method'
DATA_KODI = 'kodi'
ATTR_MEDIA_TYPE = 'media_type'
ATTR_MEDIA_NAME = 'media_name'
ATTR_MEDIA_ARTIST_NAME = 'artist_name'
ATTR_MEDIA_ID = 'media_id'
ATTR_METHOD = 'method'
TILT_ACTION = "set_cover_tilt_position"
CONF_TILT_OPTIMISTIC = "tilt_optimistic"
CONF_VALUE_OR_POSITION_TEMPLATE = "value_or_position"
CONF_OPEN_OR_CLOSE = "open_or_close"
TILT_FEATURES = (
SUPPORT_OPEN_TILT
| SUPPORT_CLOSE_TILT
| SUPPORT_STOP_TILT
| SUPPORT_SET_TILT_POSITION
)
COVER_SCHEMA = vol.Schema(
{
vol.Inclusive(OPEN_ACTION, CONF_OPEN_OR_CLOSE): cv.SCRIPT_SCHEMA,
vol.Inclusive(CLOSE_ACTION, CONF_OPEN_OR_CLOSE): cv.SCRIPT_SCHEMA,
vol.Optional(STOP_ACTION): cv.SCRIPT_SCHEMA,
vol.Exclusive(
CONF_POSITION_TEMPLATE, CONF_VALUE_OR_POSITION_TEMPLATE
): cv.template,
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_DEVICE_CLASS): DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_OPTIMISTIC): cv.boolean,
vol.Optional(CONF_TILT_OPTIMISTIC): cv.boolean,
DEFAULT_TIMEOUT = 10
DEFAULT_METHOD = "get"
DEFAULT_VERIFY_SSL = True
SUPPORT_REST_METHODS = ["get", "post", "put", "delete"]
CONF_CONTENT_TYPE = "content_type"
COMMAND_SCHEMA = vol.Schema({
vol.Required(CONF_URL):
cv.template,
vol.Optional(CONF_METHOD, default=DEFAULT_METHOD):
vol.All(vol.Lower, vol.In(SUPPORT_REST_METHODS)),
vol.Optional(CONF_HEADERS):
vol.Schema({cv.string: cv.string}),
vol.Inclusive(CONF_USERNAME, "authentication"):
cv.string,
vol.Inclusive(CONF_PASSWORD, "authentication"):
cv.string,
vol.Optional(CONF_PAYLOAD):
cv.template,
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT):
vol.Coerce(int),
vol.Optional(CONF_CONTENT_TYPE):
cv.string,
vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL):
cv.boolean,
})
CONFIG_SCHEMA = vol.Schema({DOMAIN: cv.schema_with_slug_keys(COMMAND_SCHEMA)},
extra=vol.ALLOW_EXTRA)
STATIONS_URI = "v2/networks/{uid}?fields=network.stations"
CITYBIKES_ATTRIBUTION = (
"Information provided by the CityBikes Project (https://citybik.es/#about)"
)
CITYBIKES_NETWORKS = "citybikes_networks"
PLATFORM_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_RADIUS, CONF_STATIONS_LIST),
PLATFORM_SCHEMA.extend({
vol.Optional(CONF_NAME, default=""):
cv.string,
vol.Optional(CONF_NETWORK):
cv.string,
vol.Inclusive(CONF_LATITUDE, "coordinates"):
cv.latitude,
vol.Inclusive(CONF_LONGITUDE, "coordinates"):
cv.longitude,
vol.Optional(CONF_RADIUS, "station_filter"):
cv.positive_int,
vol.Optional(CONF_STATIONS_LIST, "station_filter"):
vol.All(cv.ensure_list, vol.Length(min=1), [cv.string]),
}),
)
NETWORK_SCHEMA = vol.Schema(
{
vol.Required(ATTR_ID):
cv.string,
vol.Required(ATTR_NAME):
SUPPORT_REST_METHODS = ["post", "put"]
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_RESOURCE): cv.url,
vol.Optional(CONF_HEADERS): {cv.string: cv.string},
vol.Optional(CONF_BODY_OFF, default=DEFAULT_BODY_OFF): cv.template,
vol.Optional(CONF_BODY_ON, default=DEFAULT_BODY_ON): cv.template,
vol.Optional(CONF_IS_ON_TEMPLATE): cv.template,
vol.Optional(CONF_METHOD, default=DEFAULT_METHOD): vol.All(
vol.Lower, vol.In(SUPPORT_REST_METHODS)
),
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
vol.Inclusive(CONF_USERNAME, "authentication"): cv.string,
vol.Inclusive(CONF_PASSWORD, "authentication"): cv.string,
vol.Optional(CONF_VERIFY_SSL, default=DEFAULT_VERIFY_SSL): cv.boolean,
}
)
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the RESTful switch."""
body_off = config.get(CONF_BODY_OFF)
body_on = config.get(CONF_BODY_ON)
is_on_template = config.get(CONF_IS_ON_TEMPLATE)
method = config.get(CONF_METHOD)
headers = config.get(CONF_HEADERS)
name = config.get(CONF_NAME)
username = config.get(CONF_USERNAME)
DEFAULT_NAME = "MQTT Vacuum"
DEFAULT_PAYLOAD_CLEAN_SPOT = "clean_spot"
DEFAULT_PAYLOAD_LOCATE = "locate"
DEFAULT_PAYLOAD_RETURN_TO_BASE = "return_to_base"
DEFAULT_PAYLOAD_START_PAUSE = "start_pause"
DEFAULT_PAYLOAD_STOP = "stop"
DEFAULT_PAYLOAD_TURN_OFF = "turn_off"
DEFAULT_PAYLOAD_TURN_ON = "turn_on"
DEFAULT_RETAIN = False
DEFAULT_SERVICE_STRINGS = services_to_strings(DEFAULT_SERVICES,
SERVICE_TO_STRING)
PLATFORM_SCHEMA_LEGACY = (mqtt.MQTT_BASE_PLATFORM_SCHEMA.extend(
{
vol.Inclusive(CONF_BATTERY_LEVEL_TEMPLATE, "battery"):
cv.template,
vol.Inclusive(CONF_BATTERY_LEVEL_TOPIC, "battery"):
mqtt.valid_publish_topic,
vol.Inclusive(CONF_CHARGING_TEMPLATE, "charging"):
cv.template,
vol.Inclusive(CONF_CHARGING_TOPIC, "charging"):
mqtt.valid_publish_topic,
vol.Inclusive(CONF_CLEANING_TEMPLATE, "cleaning"):
cv.template,
vol.Inclusive(CONF_CLEANING_TOPIC, "cleaning"):
mqtt.valid_publish_topic,
vol.Optional(CONF_DEVICE):
mqtt.MQTT_ENTITY_DEVICE_INFO_SCHEMA,
vol.Inclusive(CONF_DOCKED_TEMPLATE, "docked"):
cv.template,
def validate_station(station):
"""Check that the station ID is well-formed."""
if station is None:
return
if not re.fullmatch(r"[A-Z]{2}/s0000\d{3}", station):
raise vol.error.Invalid('Station ID must be of the form "XX/s0000###"')
return station
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Optional(CONF_NAME):
cv.string,
vol.Optional(CONF_STATION):
validate_station,
vol.Inclusive(CONF_LATITUDE, "latlon"):
cv.latitude,
vol.Inclusive(CONF_LONGITUDE, "latlon"):
cv.longitude,
vol.Optional(CONF_FORECAST, default="daily"):
vol.In(["daily", "hourly"]),
})
# Icon codes from http://dd.weatheroffice.ec.gc.ca/citypage_weather/
# docs/current_conditions_icon_code_descriptions_e.csv
ICON_CONDITION_MAP = {
ATTR_CONDITION_SUNNY: [0, 1],
ATTR_CONDITION_CLEAR_NIGHT: [30, 31],
ATTR_CONDITION_PARTLYCLOUDY: [2, 3, 4, 5, 22, 32, 33, 34, 35],
ATTR_CONDITION_CLOUDY: [10],
ATTR_CONDITION_RAINY: [6, 9, 11, 12, 28, 36],
ATTR_SENSOR_DEVICE_CLASS = "device_class"
ATTR_SENSOR_ENTITY_CATEGORY = "entity_category"
ATTR_SENSOR_ICON = "icon"
ATTR_SENSOR_NAME = "name"
ATTR_SENSOR_STATE = "state"
ATTR_SENSOR_STATE_CLASS = "state_class"
ATTR_SENSOR_TYPE = "type"
ATTR_SENSOR_TYPE_BINARY_SENSOR = "binary_sensor"
ATTR_SENSOR_TYPE_SENSOR = "sensor"
ATTR_SENSOR_UNIQUE_ID = "unique_id"
ATTR_SENSOR_UOM = "unit_of_measurement"
SIGNAL_SENSOR_UPDATE = f"{DOMAIN}_sensor_update"
SIGNAL_LOCATION_UPDATE = DOMAIN + "_location_update_{}"
ATTR_CAMERA_ENTITY_ID = "camera_entity_id"
SCHEMA_APP_DATA = vol.Schema(
{
vol.Inclusive(ATTR_PUSH_TOKEN, "push_cloud"):
cv.string,
vol.Inclusive(ATTR_PUSH_URL, "push_cloud"):
cv.url,
# Set to True to indicate that this registration will connect via websocket channel
# to receive push notifications.
vol.Optional(ATTR_PUSH_WEBSOCKET_CHANNEL):
cv.boolean,
},
extra=vol.ALLOW_EXTRA,
)
DEFAULT_INIT_STATE = True
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_INPUT):
cv.string,
vol.Optional(CONF_INITIAL_STATE, default=DEFAULT_INIT_STATE):
cv.boolean,
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_EXTRA_ARGUMENTS):
cv.string,
vol.Optional(CONF_RESET, default=10):
vol.All(vol.Coerce(int), vol.Range(min=1)),
vol.Optional(CONF_CHANGES, default=10):
vol.All(vol.Coerce(float), vol.Range(min=0, max=99)),
vol.Inclusive(CONF_REPEAT, 'repeat'):
vol.All(vol.Coerce(int), vol.Range(min=1)),
vol.Inclusive(CONF_REPEAT_TIME, 'repeat'):
vol.All(vol.Coerce(int), vol.Range(min=1)),
})
async def async_setup_platform(hass,
config,
async_add_entities,
discovery_info=None):
"""Set up the FFmpeg binary motion sensor."""
manager = hass.data[DATA_FFMPEG]
if not await manager.async_run_test(config.get(CONF_INPUT)):
return
HTTP_SCHEMA = vol.Schema({
vol.Optional(CONF_SERVER_HOST, default=DEFAULT_SERVER_HOST):
cv.string,
vol.Optional(CONF_SERVER_PORT, default=SERVER_PORT):
cv.port,
vol.Optional(CONF_BASE_URL):
cv.string,
vol.Optional(CONF_SSL_CERTIFICATE):
cv.isfile,
vol.Optional(CONF_SSL_PEER_CERTIFICATE):
cv.isfile,
vol.Optional(CONF_SSL_KEY):
cv.isfile,
vol.Optional(CONF_CORS_ORIGINS, default=[DEFAULT_CORS]):
vol.All(cv.ensure_list, [cv.string]),
vol.Inclusive(CONF_USE_X_FORWARDED_FOR, "proxy"):
cv.boolean,
vol.Inclusive(CONF_TRUSTED_PROXIES, "proxy"):
vol.All(cv.ensure_list, [ip_network]),
vol.Optional(CONF_LOGIN_ATTEMPTS_THRESHOLD,
default=NO_LOGIN_ATTEMPT_THRESHOLD):
vol.Any(cv.positive_int, NO_LOGIN_ATTEMPT_THRESHOLD),
vol.Optional(CONF_IP_BAN_ENABLED, default=True):
cv.boolean,
vol.Optional(CONF_SSL_PROFILE, default=SSL_MODERN):
vol.In([SSL_INTERMEDIATE, SSL_MODERN]),
})
CONFIG_SCHEMA = vol.Schema({DOMAIN: HTTP_SCHEMA}, extra=vol.ALLOW_EXTRA)
SET_AWAY_MODE_SCHEMA = vol.Schema({
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(ATTR_AWAY_MODE): cv.boolean,
})
SET_AUX_HEAT_SCHEMA = vol.Schema({
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(ATTR_AUX_HEAT): cv.boolean,
})
SET_TEMPERATURE_SCHEMA = vol.Schema(
vol.All(
cv.has_at_least_one_key(ATTR_TEMPERATURE, ATTR_TARGET_TEMP_HIGH,
ATTR_TARGET_TEMP_LOW),
{
vol.Exclusive(ATTR_TEMPERATURE, 'temperature'): vol.Coerce(float),
vol.Inclusive(ATTR_TARGET_TEMP_HIGH, 'temperature'):
vol.Coerce(float),
vol.Inclusive(ATTR_TARGET_TEMP_LOW, 'temperature'):
vol.Coerce(float),
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Optional(ATTR_OPERATION_MODE): cv.string,
}))
SET_FAN_MODE_SCHEMA = vol.Schema({
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(ATTR_FAN_MODE): cv.string,
})
SET_HOLD_MODE_SCHEMA = vol.Schema({
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(ATTR_HOLD_MODE): cv.string,
})
SET_OPERATION_MODE_SCHEMA = vol.Schema({
ATTR_ENABLED = "enabled"
ATTR_AUTO_SHUTOFF = "auto_shutoff"
VOLUMES = ["low", "medium", "high"]
TONES = [
"doorbell", "fur_elise", "doorbell_extended", "alert", "william_tell",
"rondo_alla_turca", "police_siren", "evacuation", "beep_beep", "beep"
]
CHIME_TONES = TONES + ["inactive"]
AUTO_SHUTOFF_TIMES = [None, -1, 30, 60, 120]
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema({
vol.Inclusive(CONF_EMAIL, CONF_OAUTH, msg=CONF_MISSING_OAUTH_MSG):
cv.string,
vol.Inclusive(CONF_PASSWORD,
CONF_OAUTH,
msg=CONF_MISSING_OAUTH_MSG):
cv.string,
vol.Inclusive(CONF_CLIENT_ID,
CONF_OAUTH,
msg=CONF_MISSING_OAUTH_MSG):
cv.string,
vol.Inclusive(CONF_CLIENT_SECRET,
CONF_OAUTH,
msg=CONF_MISSING_OAUTH_MSG):
cv.string,
vol.Optional(CONF_LOCAL_CONTROL, default=False):
cv.boolean
SERVICE_SET_ZWAVE_PARAMETER_SCHEMA = {
vol.Required(CONF_PARAMETER):
vol.Coerce(int),
vol.Required(CONF_VALUE):
vol.Coerce(int),
vol.Required(CONF_SIZE):
vol.All(vol.Coerce(int), vol.In(VALID_PARAMETER_SIZES)),
}
SERVICE_SET_VARIABLE_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_ADDRESS, CONF_TYPE, CONF_NAME),
vol.Schema({
vol.Exclusive(CONF_NAME, SCHEMA_GROUP):
cv.string,
vol.Inclusive(CONF_ADDRESS, SCHEMA_GROUP):
vol.Coerce(int),
vol.Inclusive(CONF_TYPE, SCHEMA_GROUP):
vol.All(vol.Coerce(int), vol.Range(1, 2)),
vol.Optional(CONF_INIT, default=False):
bool,
vol.Required(CONF_VALUE):
vol.Coerce(int),
vol.Optional(CONF_ISY):
cv.string,
}),
)
SERVICE_SEND_PROGRAM_COMMAND_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_ADDRESS, CONF_NAME),
vol.Schema({
)
from homeassistant.helpers.typing import ConfigType
from .const import (
DATA_SPOTIFY_CLIENT,
DATA_SPOTIFY_ME,
DATA_SPOTIFY_SESSION,
DOMAIN,
SPOTIFY_SCOPES,
)
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN: vol.Schema(
{
vol.Inclusive(CONF_CLIENT_ID, ATTR_CREDENTIALS): cv.string,
vol.Inclusive(CONF_CLIENT_SECRET, ATTR_CREDENTIALS): cv.string,
}
)
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up the Spotify integration."""
if DOMAIN not in config:
return True
if CONF_CLIENT_ID in config[DOMAIN]:
config_flow.SpotifyFlowHandler.async_register_implementation(
CLOSE_ACTION = "close_cover"
STOP_ACTION = "stop_cover"
POSITION_ACTION = "set_cover_position"
TILT_ACTION = "set_cover_tilt_position"
CONF_TILT_OPTIMISTIC = "tilt_optimistic"
CONF_VALUE_OR_POSITION_TEMPLATE = "value_or_position"
CONF_OPEN_OR_CLOSE = "open_or_close"
TILT_FEATURES = (SUPPORT_OPEN_TILT
| SUPPORT_CLOSE_TILT
| SUPPORT_STOP_TILT
| SUPPORT_SET_TILT_POSITION)
COVER_SCHEMA = vol.Schema({
vol.Inclusive(OPEN_ACTION, CONF_OPEN_OR_CLOSE):
cv.SCRIPT_SCHEMA,
vol.Inclusive(CLOSE_ACTION, CONF_OPEN_OR_CLOSE):
cv.SCRIPT_SCHEMA,
vol.Optional(STOP_ACTION):
cv.SCRIPT_SCHEMA,
vol.Exclusive(CONF_POSITION_TEMPLATE, CONF_VALUE_OR_POSITION_TEMPLATE):
cv.template,
vol.Exclusive(CONF_VALUE_TEMPLATE, CONF_VALUE_OR_POSITION_TEMPLATE):
cv.template,
vol.Optional(CONF_AVAILABILITY_TEMPLATE):
cv.template,
vol.Optional(CONF_POSITION_TEMPLATE):
cv.template,
vol.Optional(CONF_TILT_TEMPLATE):
cv.template,
def is_socket_address(value):
"""Validate that value is a valid address."""
try:
socket.getaddrinfo(value, None)
return value
except OSError:
raise vol.Invalid('Device is not a valid domain name or ip address')
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema({
vol.Inclusive(CONF_USERNAME, 'auth'):
cv.string,
vol.Inclusive(CONF_PASSWORD, 'auth'):
cv.string,
vol.Optional(CONF_HOST, default=DEFAULT_HOST):
#vol.All(cv.string, is_socket_address),
cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT):
cv.port,
vol.Optional(CONF_VERIFY_HTTPS, default=DEFAULT_VERIFY_HTTPS):
cv.boolean,
})
},
extra=vol.ALLOW_EXTRA)
CONF_COMMUNITY = 'community'
CONF_AUTHKEY = 'authkey'
CONF_PRIVKEY = 'privkey'
CONF_BASEOID = 'baseoid'
DEFAULT_COMMUNITY = 'public'
MIN_TIME_BETWEEN_SCANS = timedelta(seconds=10)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(CONF_HOST):
cv.string,
vol.Optional(CONF_COMMUNITY, default=DEFAULT_COMMUNITY):
cv.string,
vol.Inclusive(CONF_AUTHKEY, 'keys'):
cv.string,
vol.Inclusive(CONF_PRIVKEY, 'keys'):
cv.string,
vol.Required(CONF_BASEOID):
cv.string
})
# pylint: disable=unused-argument
def get_scanner(hass, config):
"""Validate the configuration and return an snmp scanner."""
scanner = SnmpScanner(config[DOMAIN])
return scanner if scanner.success_init else None