def gen_strings_schema(config: Config, integration: Integration):
"""Generate a strings schema."""
return vol.Schema({
vol.Optional("title"):
cv.string_with_no_html,
vol.Optional("config"):
gen_data_entry_schema(
config=config,
integration=integration,
flow_title=REMOVED,
require_step_title=False,
),
vol.Optional("options"):
gen_data_entry_schema(
config=config,
integration=integration,
flow_title=UNDEFINED,
require_step_title=False,
),
vol.Optional("device_automation"): {
vol.Optional("action_type"): {
str: cv.string_with_no_html
},
vol.Optional("condition_type"): {
str: cv.string_with_no_html
},
vol.Optional("trigger_type"): {
str: cv.string_with_no_html
},
vol.Optional("trigger_subtype"): {
str: cv.string_with_no_html
},
},
vol.Optional("state"):
cv.schema_with_slug_keys(
cv.schema_with_slug_keys(str, slug_validator=lowercase_validator),
slug_validator=vol.Any("_", cv.slug),
),
vol.Optional("system_health"): {
vol.Optional("info"): {
str: cv.string_with_no_html
}
},
vol.Optional("config_panel"):
cv.schema_with_slug_keys(
cv.schema_with_slug_keys(cv.string_with_no_html,
slug_validator=lowercase_validator),
slug_validator=vol.Any("_", cv.slug),
),
})
def gen_platform_strings_schema(config: Config, integration: Integration):
"""Generate platform strings schema like strings.sensor.json.
Example of valid data:
{
"state": {
"moon__phase": {
"full": "Full"
}
}
}
"""
def device_class_validator(value):
"""Key validator for platorm states.
Platform states are only allowed to provide states for device classes they prefix.
"""
if not value.startswith(f"{integration.domain}__"):
raise vol.Invalid(
f"Device class need to start with '{integration.domain}__'. Key {value} is invalid. See https://developers.openpeerpower.io/docs/internationalization/core#stringssensorjson"
)
slug_friendly = value.replace("__", "_", 1)
slugged = slugify(slug_friendly)
if slug_friendly != slugged:
raise vol.Invalid(
f"invalid device class {value}. After domain__, needs to be all lowercase, no spaces."
)
return value
return vol.Schema({
vol.Optional("state"):
cv.schema_with_slug_keys(
cv.schema_with_slug_keys(str, slug_validator=lowercase_validator),
slug_validator=device_class_validator,
)
})
from openpeerpower.core import EVENT_OPENPEERPOWER_START, callback
from openpeerpower.exceptions import TemplateError
from openpeerpower.helpers import config_validation as cv
from openpeerpower.helpers.event import TrackTemplate, async_track_template_result
from openpeerpower.helpers.reload import async_setup_reload_service
from openpeerpower.helpers.service import async_call_from_config
ATTR_ACTIVE_CHILD = "active_child"
CONF_ATTRS = "attributes"
CONF_CHILDREN = "children"
CONF_COMMANDS = "commands"
OFF_STATES = [STATE_IDLE, STATE_OFF, STATE_UNAVAILABLE]
ATTRS_SCHEMA = cv.schema_with_slug_keys(cv.string)
CMD_SCHEMA = cv.schema_with_slug_keys(cv.SERVICE_SCHEMA)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_NAME):
cv.string,
vol.Optional(CONF_CHILDREN, default=[]):
cv.entity_ids,
vol.Optional(CONF_COMMANDS, default={}):
CMD_SCHEMA,
vol.Optional(CONF_ATTRS, default={}):
vol.Or(cv.ensure_list(ATTRS_SCHEMA), ATTRS_SCHEMA),
vol.Optional(CONF_DEVICE_CLASS):
DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_STATE_TEMPLATE):
_LOGGER = logging.getLogger(__name__)
DEFAULT_PORT = 80
DEFAULT_PATH = "/cgi-bin/json.cgi"
SWITCH_SCHEMA = vol.Schema({
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_NAME): cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
vol.Optional(CONF_PATH, default=DEFAULT_PATH): cv.string,
vol.Optional(CONF_USERNAME): cv.string,
vol.Optional(CONF_PASSWORD): cv.string,
})
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(CONF_SWITCHES): cv.schema_with_slug_keys(SWITCH_SCHEMA)})
def setup_platform(opp, config, add_entities_callback, discovery_info=None):
"""Set up Kankun Wifi switches."""
switches = config.get("switches", {})
devices = []
for dev_name, properties in switches.items():
devices.append(
KankunSwitch(
opp,
properties.get(CONF_NAME, dev_name),
properties.get(CONF_HOST),
properties.get(CONF_PORT, DEFAULT_PORT),
properties.get(CONF_PATH, DEFAULT_PATH),
"""Support for SCSGate lights."""
import logging
from scsgate.tasks import ToggleStatusTask
import voluptuous as vol
from openpeerpower.components.light import PLATFORM_SCHEMA, LightEntity
from openpeerpower.const import ATTR_ENTITY_ID, ATTR_STATE, CONF_DEVICES, CONF_NAME
import openpeerpower.helpers.config_validation as cv
from . import CONF_SCS_ID, DOMAIN, SCSGATE_SCHEMA
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(CONF_DEVICES): cv.schema_with_slug_keys(SCSGATE_SCHEMA)}
)
def setup_platform(opp, config, add_entities, discovery_info=None):
"""Set up the SCSGate switches."""
devices = config.get(CONF_DEVICES)
lights = []
logger = logging.getLogger(__name__)
scsgate = opp.data[DOMAIN]
if devices:
for entity_info in devices.values():
if entity_info[CONF_SCS_ID] in scsgate.devices:
continue
name = entity_info[CONF_NAME]
scs_id = entity_info[CONF_SCS_ID]
Note: this is different than auth provider
"""
config_keys: set[str] = set()
for config in configs:
key = config.get(CONF_ID, config[CONF_TYPE])
if key in config_keys:
raise vol.Invalid(
f"Duplicate mfa module {config[CONF_TYPE]} found. "
"Please add unique IDs "
"if you want to have the same mfa module twice")
config_keys.add(key)
return configs
PACKAGES_CONFIG_SCHEMA = cv.schema_with_slug_keys( # Package names are slugs
vol.Schema({cv.string: vol.Any(dict, list, None)}) # Component config
)
CUSTOMIZE_DICT_SCHEMA = vol.Schema(
{
vol.Optional(ATTR_FRIENDLY_NAME): cv.string,
vol.Optional(ATTR_HIDDEN): cv.boolean,
vol.Optional(ATTR_ASSUMED_STATE): cv.boolean,
},
extra=vol.ALLOW_EXTRA,
)
CUSTOMIZE_CONFIG_SCHEMA = vol.Schema({
vol.Optional(CONF_CUSTOMIZE, default={}):
vol.Schema({cv.entity_id: CUSTOMIZE_DICT_SCHEMA}),
vol.Optional(CONF_CUSTOMIZE_DOMAIN, default={}):
vol.Optional(CONF_COLOR_ACTION): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_WHITE_VALUE_TEMPLATE): cv.template,
vol.Optional(CONF_WHITE_VALUE_ACTION): cv.SCRIPT_SCHEMA,
vol.Inclusive(CONF_EFFECT_LIST_TEMPLATE, "effect"): cv.template,
vol.Inclusive(CONF_EFFECT_TEMPLATE, "effect"): cv.template,
vol.Inclusive(CONF_EFFECT_ACTION, "effect"): cv.SCRIPT_SCHEMA,
vol.Optional(CONF_MAX_MIREDS_TEMPLATE): cv.template,
vol.Optional(CONF_MIN_MIREDS_TEMPLATE): cv.template,
vol.Optional(CONF_SUPPORTS_TRANSITION): cv.template,
vol.Optional(CONF_UNIQUE_ID): cv.string,
}
),
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(CONF_LIGHTS): cv.schema_with_slug_keys(LIGHT_SCHEMA)}
)
async def _async_create_entities(opp, config):
"""Create the Template Lights."""
lights = []
for device, device_config in config[CONF_LIGHTS].items():
friendly_name = device_config.get(CONF_FRIENDLY_NAME, device)
state_template = device_config.get(CONF_VALUE_TEMPLATE)
icon_template = device_config.get(CONF_ICON_TEMPLATE)
entity_picture_template = device_config.get(CONF_ENTITY_PICTURE_TEMPLATE)
availability_template = device_config.get(CONF_AVAILABILITY_TEMPLATE)
unique_id = device_config.get(CONF_UNIQUE_ID)
raise vol.Invalid(
f"initial state {initial} is not part of the options: {','.join(options)}"
)
return cfg
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
cv.schema_with_slug_keys(
vol.All(
{
vol.Optional(CONF_NAME):
cv.string,
vol.Required(CONF_OPTIONS):
vol.All(cv.ensure_list, vol.Length(min=1), [cv.string]),
vol.Optional(CONF_INITIAL):
cv.string,
vol.Optional(CONF_ICON):
cv.icon,
},
_cv_input_select,
))
},
extra=vol.ALLOW_EXTRA,
)
RELOAD_SERVICE_SCHEMA = vol.Schema({})
async def async_setup(opp: OpenPeerPower, config: ConfigType) -> bool:
"""Set up an input select."""
component = EntityComponent(_LOGGER, DOMAIN, opp)
vol.Optional(
CONF_SPEED_LIST,
default=[SPEED_OFF, SPEED_LOW, SPEED_MEDIUM, SPEED_HIGH],
):
cv.ensure_list,
vol.Optional(CONF_PRESET_MODES):
cv.ensure_list,
vol.Optional(CONF_ENTITY_ID):
cv.entity_ids,
vol.Optional(CONF_UNIQUE_ID):
cv.string,
}),
)
PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend(
{vol.Required(CONF_FANS): cv.schema_with_slug_keys(FAN_SCHEMA)})
async def _async_create_entities(opp, config):
"""Create the Template Fans."""
fans = []
for device, device_config in config[CONF_FANS].items():
friendly_name = device_config.get(CONF_FRIENDLY_NAME, device)
state_template = device_config[CONF_VALUE_TEMPLATE]
speed_template = device_config.get(CONF_SPEED_TEMPLATE)
percentage_template = device_config.get(CONF_PERCENTAGE_TEMPLATE)
preset_mode_template = device_config.get(CONF_PRESET_MODE_TEMPLATE)
oscillating_template = device_config.get(CONF_OSCILLATING_TEMPLATE)
direction_template = device_config.get(CONF_DIRECTION_TEMPLATE)
from openpeerpower.const import CONF_BINARY_SENSORS, CONF_SENSORS, CONF_UNIQUE_ID
from openpeerpower.helpers import config_validation as cv
from openpeerpower.helpers.trigger import async_validate_trigger_config
from . import binary_sensor as binary_sensor_platform, sensor as sensor_platform
from .const import CONF_TRIGGER, DOMAIN
CONFIG_SECTION_SCHEMA = vol.Schema({
vol.Optional(CONF_UNIQUE_ID):
cv.string,
vol.Optional(CONF_TRIGGER):
cv.TRIGGER_SCHEMA,
vol.Optional(SENSOR_DOMAIN):
vol.All(cv.ensure_list, [sensor_platform.SENSOR_SCHEMA]),
vol.Optional(CONF_SENSORS):
cv.schema_with_slug_keys(sensor_platform.LEGACY_SENSOR_SCHEMA),
vol.Optional(BINARY_SENSOR_DOMAIN):
vol.All(cv.ensure_list, [binary_sensor_platform.BINARY_SENSOR_SCHEMA]),
vol.Optional(CONF_BINARY_SENSORS):
cv.schema_with_slug_keys(
binary_sensor_platform.LEGACY_BINARY_SENSOR_SCHEMA),
})
async def async_validate_config(opp, config):
"""Validate config."""
if DOMAIN not in config:
return config
config_sections = []
cv.SCRIPT_SCHEMA,
vol.Optional(CONF_ARM_HOME_ACTION):
cv.SCRIPT_SCHEMA,
vol.Optional(CONF_ARM_NIGHT_ACTION):
cv.SCRIPT_SCHEMA,
vol.Optional(CONF_CODE_ARM_REQUIRED, default=True):
cv.boolean,
vol.Optional(CONF_NAME):
cv.string,
vol.Optional(CONF_UNIQUE_ID):
cv.string,
})
PLATFORM_SCHEMA = PARENT_PLATFORM_SCHEMA.extend({
vol.Required(CONF_ALARM_CONTROL_PANELS):
cv.schema_with_slug_keys(ALARM_CONTROL_PANEL_SCHEMA),
})
async def _async_create_entities(opp, config):
"""Create Template Alarm Control Panels."""
alarm_control_panels = []
for device, device_config in config[CONF_ALARM_CONTROL_PANELS].items():
name = device_config.get(CONF_NAME, device)
state_template = device_config.get(CONF_VALUE_TEMPLATE)
disarm_action = device_config.get(CONF_DISARM_ACTION)
arm_away_action = device_config.get(CONF_ARM_AWAY_ACTION)
arm_home_action = device_config.get(CONF_ARM_HOME_ACTION)
arm_night_action = device_config.get(CONF_ARM_NIGHT_ACTION)
code_arm_required = device_config[CONF_CODE_ARM_REQUIRED]
"any_door_open",
"any_window_open",
]
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema({
vol.Required(CONF_USERNAME):
cv.string,
vol.Required(CONF_PASSWORD):
cv.string,
vol.Optional(CONF_SCAN_INTERVAL, default=DEFAULT_UPDATE_INTERVAL):
vol.All(cv.time_period, vol.Clamp(min=MIN_UPDATE_INTERVAL)),
vol.Optional(CONF_NAME, default={}):
cv.schema_with_slug_keys(cv.string),
vol.Optional(CONF_RESOURCES):
vol.All(cv.ensure_list, [vol.In(RESOURCES)]),
vol.Optional(CONF_REGION):
cv.string,
vol.Optional(CONF_SERVICE_URL):
cv.string,
vol.Optional(CONF_MUTABLE, default=True):
cv.boolean,
vol.Optional(CONF_SCANDINAVIAN_MILES, default=False):
cv.boolean,
})
},
extra=vol.ALLOW_EXTRA,
)
vol.Optional(CONF_DEVICE_CLASS):
DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_FRIENDLY_NAME):
cv.string,
vol.Optional(CONF_INVERT, default=False):
cv.boolean,
vol.Optional(CONF_MAX_SAMPLES, default=2):
cv.positive_int,
vol.Optional(CONF_MIN_GRADIENT, default=0.0):
vol.Coerce(float),
vol.Optional(CONF_SAMPLE_DURATION, default=0):
cv.positive_int,
})
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(CONF_SENSORS): cv.schema_with_slug_keys(SENSOR_SCHEMA)})
def setup_platform(opp, config, add_entities, discovery_info=None):
"""Set up the trend sensors."""
setup_reload_service(opp, DOMAIN, PLATFORMS)
sensors = []
for device_id, device_config in config[CONF_SENSORS].items():
entity_id = device_config[ATTR_ENTITY_ID]
attribute = device_config.get(CONF_ATTRIBUTE)
device_class = device_config.get(CONF_DEVICE_CLASS)
friendly_name = device_config.get(ATTR_FRIENDLY_NAME, device_id)
invert = device_config[CONF_INVERT]
max_samples = device_config[CONF_MAX_SAMPLES]
vol.Required(CONF_UNIT): cv.string,
vol.Optional(CONF_FACTOR, default=1): vol.Coerce(float),
vol.Optional(CONF_PATH): vol.All(cv.ensure_list, [cv.string]),
}
)
PLATFORM_SCHEMA = vol.All(
PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_SSL, default=False): cv.boolean,
vol.Optional(CONF_VERIFY_SSL, default=True): cv.boolean,
vol.Required(CONF_PASSWORD): cv.string,
vol.Optional(CONF_GROUP, default=GROUPS[0]): vol.In(GROUPS),
vol.Optional(CONF_SENSORS, default=[]): vol.Any(
cv.schema_with_slug_keys(cv.ensure_list), # will be deprecated
vol.All(cv.ensure_list, [str]),
),
vol.Optional(CONF_CUSTOM, default={}): cv.schema_with_slug_keys(
CUSTOM_SCHEMA
),
},
extra=vol.PREVENT_EXTRA,
),
_check_sensor_schema,
)
async def async_setup_platform(
opp: OpenPeerPower,
config: ConfigEntry,
}
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
cv.schema_with_slug_keys(
vol.All(
{
vol.Optional(CONF_NAME):
cv.string,
vol.Required(CONF_MIN):
vol.Coerce(float),
vol.Required(CONF_MAX):
vol.Coerce(float),
vol.Optional(CONF_INITIAL):
vol.Coerce(float),
vol.Optional(CONF_STEP, default=1):
vol.All(vol.Coerce(float), vol.Range(min=1e-3)),
vol.Optional(CONF_ICON):
cv.icon,
vol.Optional(ATTR_UNIT_OF_MEASUREMENT):
cv.string,
vol.Optional(CONF_MODE, default=MODE_SLIDER):
vol.In([MODE_BOX, MODE_SLIDER]),
},
_cv_input_number,
))
},
extra=vol.ALLOW_EXTRA,
)
RELOAD_SERVICE_SCHEMA = vol.Schema({})
STORAGE_KEY = DOMAIN
"""Check at least date or time is true."""
if conf[CONF_HAS_DATE] or conf[CONF_HAS_TIME]:
return conf
raise vol.Invalid("Entity needs at least a date or a time")
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
cv.schema_with_slug_keys(
vol.All(
{
vol.Optional(CONF_NAME): cv.string,
vol.Optional(CONF_HAS_DATE, default=False): cv.boolean,
vol.Optional(CONF_HAS_TIME, default=False): cv.boolean,
vol.Optional(CONF_ICON): cv.icon,
vol.Optional(CONF_INITIAL): cv.string,
},
has_date_or_time,
))
},
extra=vol.ALLOW_EXTRA,
)
RELOAD_SERVICE_SCHEMA = vol.Schema({})
async def async_setup(opp: OpenPeerPower, config: ConfigType) -> bool:
"""Set up an input datetime."""
component = EntityComponent(_LOGGER, DOMAIN, opp)
id_manager = collection.IDManager()
vol.Schema({cv.string: cv.template}),
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)
async def async_setup(opp, config):
"""Set up the REST command component."""
@callback
def async_register_rest_command(name, command_config):
"""Create service for rest command."""
websession = async_get_clientsession(
opp, command_config.get(CONF_VERIFY_SSL))
timeout = command_config[CONF_TIMEOUT]
method = command_config[CONF_METHOD]
template_url = command_config[CONF_URL]
template_url.opp = opp
CONF_INITIAL = "initial"
CREATE_FIELDS = {
vol.Required(CONF_NAME): vol.All(str, vol.Length(min=1)),
vol.Optional(CONF_INITIAL): cv.boolean,
vol.Optional(CONF_ICON): cv.icon,
}
UPDATE_FIELDS = {
vol.Optional(CONF_NAME): cv.string,
vol.Optional(CONF_INITIAL): cv.boolean,
vol.Optional(CONF_ICON): cv.icon,
}
CONFIG_SCHEMA = vol.Schema(
{DOMAIN: cv.schema_with_slug_keys(vol.Any(UPDATE_FIELDS, None))},
extra=vol.ALLOW_EXTRA,
)
RELOAD_SERVICE_SCHEMA = vol.Schema({})
STORAGE_KEY = DOMAIN
STORAGE_VERSION = 1
class InputBooleanStorageCollection(collection.StorageCollection):
"""Input boolean collection stored in storage."""
CREATE_SCHEMA = vol.Schema(CREATE_FIELDS)
UPDATE_SCHEMA = vol.Schema(UPDATE_FIELDS)
async def _process_create_data(self, data: typing.Dict) -> typing.Dict:
vol.Optional(CONF_ICON):
cv.icon,
vol.Required(CONF_SEQUENCE):
cv.SCRIPT_SCHEMA,
vol.Optional(CONF_DESCRIPTION, default=""):
cv.string,
vol.Optional(CONF_FIELDS, default={}): {
cv.string: {
vol.Optional(CONF_DESCRIPTION): cv.string,
vol.Optional(CONF_EXAMPLE): cv.string,
}
},
})
CONFIG_SCHEMA = vol.Schema(
{DOMAIN: cv.schema_with_slug_keys(SCRIPT_ENTRY_SCHEMA)},
extra=vol.ALLOW_EXTRA)
SCRIPT_SERVICE_SCHEMA = vol.Schema(dict)
SCRIPT_TURN_ONOFF_SCHEMA = make_entity_service_schema(
{vol.Optional(ATTR_VARIABLES): dict})
RELOAD_SERVICE_SCHEMA = vol.Schema({})
@bind_opp
def is_on(opp, entity_id):
"""Return if the script is on based on the statemachine."""
return opp.states.is_state(entity_id, STATE_ON)
@callback
entity_cfg[to_key] = val
if CONF_NAME not in entity_cfg:
entity_cfg[CONF_NAME] = template.Template(object_id)
sensors.append(entity_cfg)
return sensors
PLATFORM_SCHEMA = vol.All(
PLATFORM_SCHEMA.extend({
vol.Optional(CONF_TRIGGER):
cv.match_all, # to raise custom warning
vol.Required(CONF_SENSORS):
cv.schema_with_slug_keys(LEGACY_SENSOR_SCHEMA),
}),
extra_validation_checks,
)
@callback
def _async_create_template_tracking_entities(async_add_entities, opp,
definitions: list[dict],
unique_id_prefix: str | None):
"""Create the template sensors."""
sensors = []
for entity_conf in definitions:
# Still available on legacy
object_id = entity_conf.get(CONF_OBJECT_ID)
import voluptuous as vol
from openpeerpower.core import OpenPeerPower, ServiceCall
from openpeerpower.exceptions import TemplateError
from openpeerpower.helpers import config_validation as cv, template
from openpeerpower.helpers.typing import ConfigType
DOMAIN = "shell_command"
COMMAND_TIMEOUT = 60
_LOGGER = logging.getLogger(__name__)
CONFIG_SCHEMA = vol.Schema(
{DOMAIN: cv.schema_with_slug_keys(cv.string)}, extra=vol.ALLOW_EXTRA
)
async def async_setup(opp: OpenPeerPower, config: ConfigType) -> bool:
"""Set up the shell_command component."""
conf = config.get(DOMAIN, {})
cache: dict[str, tuple[str, str | None, template.Template | None]] = {}
async def async_service_handler(service: ServiceCall) -> None:
"""Execute a shell command service."""
cmd = conf[service.service]
if cmd in cache:
prog, args, args_compiled = cache[cmd]
def _none_to_empty_dict(value):
if value is None:
return {}
return value
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
cv.schema_with_slug_keys(
vol.All(
_none_to_empty_dict,
{
vol.Optional(CONF_NAME):
cv.string,
vol.Optional(CONF_ICON):
cv.icon,
vol.Optional(CONF_DURATION, default=DEFAULT_DURATION):
cv.time_period,
},
))
},
extra=vol.ALLOW_EXTRA,
)
RELOAD_SERVICE_SCHEMA = vol.Schema({})
async def async_setup(opp: OpenPeerPowerType, config: ConfigType) -> bool:
"""Set up an input select."""
component = EntityComponent(_LOGGER, DOMAIN, opp)
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]),
),
}),
)
async def async_setup_platform(opp,
config,
async_add_entities,
discovery_info=None):
"""Import the device and set up custom switches.
This is for backward compatibility.
Do not use this method.
"""
_LOGGER = logging.getLogger(__name__)
CLIMATE_SCHEMA = vol.Schema({
vol.Optional(CONF_PRECISION):
vol.In([PRECISION_TENTHS, PRECISION_HALVES, PRECISION_WHOLE]),
vol.Optional(CONF_FLOOR_TEMP, default=False):
cv.boolean,
})
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
cv.schema_with_slug_keys({
vol.Required(CONF_DEVICE): cv.string,
vol.Optional(CONF_CLIMATE, default={}): CLIMATE_SCHEMA,
vol.Optional(CONF_NAME): cv.string,
})
},
extra=vol.ALLOW_EXTRA,
)
PLATFORMS = [COMP_BINARY_SENSOR, COMP_CLIMATE, COMP_SENSOR]
async def options_updated(opp, entry):
"""Handle options update."""
gateway = opp.data[DATA_OPENTHERM_GW][DATA_GATEWAYS][entry.data[CONF_ID]]
async_dispatcher_send(opp, gateway.options_update_signal, entry)
]
ZONE_SCHEMA = vol.Schema({
vol.Optional(CONF_ZONE, default=DEFAULT_PROXIMITY_ZONE):
cv.string,
vol.Optional(CONF_DEVICES, default=[]):
vol.All(cv.ensure_list, [cv.entity_id]),
vol.Optional(CONF_IGNORED_ZONES, default=[]):
vol.All(cv.ensure_list, [cv.string]),
vol.Optional(CONF_TOLERANCE, default=DEFAULT_TOLERANCE):
cv.positive_int,
vol.Optional(CONF_UNIT_OF_MEASUREMENT):
vol.All(cv.string, vol.In(UNITS)),
})
CONFIG_SCHEMA = vol.Schema({DOMAIN: cv.schema_with_slug_keys(ZONE_SCHEMA)},
extra=vol.ALLOW_EXTRA)
def setup_proximity_component(opp, name, config):
"""Set up the individual proximity component."""
ignored_zones = config.get(CONF_IGNORED_ZONES)
proximity_devices = config.get(CONF_DEVICES)
tolerance = config.get(CONF_TOLERANCE)
proximity_zone = name
unit_of_measurement = config.get(CONF_UNIT_OF_MEASUREMENT,
opp.config.units.length_unit)
zone_id = f"zone.{config.get(CONF_ZONE)}"
proximity = Proximity(
opp,
{
**DASHBOARD_BASE_CREATE_FIELDS,
vol.Required(CONF_MODE): MODE_YAML,
vol.Required(CONF_FILENAME): cv.path,
}
)
CONFIG_SCHEMA = vol.Schema(
{
vol.Optional(DOMAIN, default={}): vol.Schema(
{
vol.Optional(CONF_MODE, default=MODE_STORAGE): vol.All(
vol.Lower, vol.In([MODE_YAML, MODE_STORAGE])
),
vol.Optional(CONF_DASHBOARDS): cv.schema_with_slug_keys(
YAML_DASHBOARD_SCHEMA,
slug_validator=url_slug,
),
vol.Optional(CONF_RESOURCES): [RESOURCE_SCHEMA],
}
)
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(opp: OpenPeerPower, config: ConfigType):
"""Set up the Lovelace commands."""
mode = config[DOMAIN][CONF_MODE]
yaml_resources = config[DOMAIN].get(CONF_RESOURCES)
frontend.async_register_built_in_panel(opp, DOMAIN, config={"mode": mode})
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
cv.schema_with_slug_keys(
vol.All(
lambda value: value or {},
{
vol.Optional(CONF_NAME):
cv.string,
vol.Optional(CONF_MIN, default=CONF_MIN_VALUE):
vol.Coerce(int),
vol.Optional(CONF_MAX, default=CONF_MAX_VALUE):
vol.Coerce(int),
vol.Optional(CONF_INITIAL, ""):
cv.string,
vol.Optional(CONF_ICON):
cv.icon,
vol.Optional(CONF_UNIT_OF_MEASUREMENT):
cv.string,
vol.Optional(CONF_PATTERN):
cv.string,
vol.Optional(CONF_MODE, default=MODE_TEXT):
vol.In([MODE_TEXT, MODE_PASSWORD]),
},
_cv_input_text,
), )
},
extra=vol.ALLOW_EXTRA,
)
RELOAD_SERVICE_SCHEMA = vol.Schema({})
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,
vol.Optional(CONF_UNIQUE_ID):
cv.string,
}),
cv.has_at_least_one_key(OPEN_ACTION, POSITION_ACTION),
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(CONF_COVERS): cv.schema_with_slug_keys(COVER_SCHEMA)})
async def _async_create_entities(opp, config):
"""Create the Template cover."""
covers = []
for device, device_config in config[CONF_COVERS].items():
state_template = device_config.get(CONF_VALUE_TEMPLATE)
position_template = device_config.get(CONF_POSITION_TEMPLATE)
tilt_template = device_config.get(CONF_TILT_TEMPLATE)
icon_template = device_config.get(CONF_ICON_TEMPLATE)
availability_template = device_config.get(CONF_AVAILABILITY_TEMPLATE)
entity_picture_template = device_config.get(
CONF_ENTITY_PICTURE_TEMPLATE)
CONF_RELATIVE_URL_ERROR_MSG = "Invalid relative URL. Absolute path required."
CONF_RELATIVE_URL_REGEX = r"\A/"
CONF_REQUIRE_ADMIN = "require_admin"
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
cv.schema_with_slug_keys(
vol.Schema({
# pylint: disable=no-value-for-parameter
vol.Optional(CONF_TITLE):
cv.string,
vol.Optional(CONF_ICON):
cv.icon,
vol.Optional(CONF_REQUIRE_ADMIN, default=False):
cv.boolean,
vol.Required(CONF_URL):
vol.Any(
vol.Match(CONF_RELATIVE_URL_REGEX,
msg=CONF_RELATIVE_URL_ERROR_MSG),
vol.Url(),
),
}))
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(opp, config):
"""Set up the iFrame frontend panels."""
for url_path, info in config[DOMAIN].items():
COMMAND_SCHEMA = vol.Schema(
{vol.Required(CONF_COMMAND): vol.All(cv.ensure_list, [cv.string])}
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Optional(CONF_NAME): cv.string,
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_TIMEOUT, default=DEFAULT_TIMEOUT): cv.positive_int,
vol.Optional(CONF_SLOT, default=DEFAULT_SLOT): vol.All(
int, vol.Range(min=1, max=1000000)
),
vol.Required(CONF_TOKEN): vol.All(str, vol.Length(min=32, max=32)),
vol.Optional(CONF_COMMANDS, default={}): cv.schema_with_slug_keys(
COMMAND_SCHEMA
),
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup_platform(opp, config, async_add_entities, discovery_info=None):
"""Set up the Xiaomi IR Remote (Chuangmi IR) platform."""
host = config[CONF_HOST]
token = config[CONF_TOKEN]
# Create handler
_LOGGER.info("Initializing with host %s (token %s...)", host, token[:5])
# The Chuang Mi IR Remote Controller wants to be re-discovered every
