def test_has_at_least_one_key():
"""Test has_at_least_one_key validator."""
schema = vol.Schema(cv.has_at_least_one_key("beer", "soda"))
for value in (None, [], {}, {"wine": None}):
with pytest.raises(vol.MultipleInvalid):
schema(value)
for value in ({"beer": None}, {"soda": None}):
schema(value)
ATTR_ENTRY_ID = "entry_id"
_LOGGER = logging.getLogger(__name__)
DOMAIN = ha.DOMAIN
SERVICE_RELOAD_CORE_CONFIG = "reload_core_config"
SERVICE_RELOAD_CONFIG_ENTRY = "reload_config_entry"
SERVICE_CHECK_CONFIG = "check_config"
SERVICE_UPDATE_ENTITY = "update_entity"
SERVICE_SET_LOCATION = "set_location"
SCHEMA_UPDATE_ENTITY = vol.Schema({ATTR_ENTITY_ID: cv.entity_ids})
SCHEMA_RELOAD_CONFIG_ENTRY = vol.All(
vol.Schema({
vol.Optional(ATTR_ENTRY_ID): str,
**cv.ENTITY_SERVICE_FIELDS,
}, ),
cv.has_at_least_one_key(ATTR_ENTRY_ID, *cv.ENTITY_SERVICE_FIELDS),
)
SHUTDOWN_SERVICES = (SERVICE_OPENPEERPOWER_STOP, SERVICE_OPENPEERPOWER_RESTART)
async def async_setup(opp: ha.OpenPeerPower,
config: dict) -> bool: # noqa: C901
"""Set up general services related to Open Peer Power."""
async def async_handle_turn_service(service):
"""Handle calls to openpeerpower.turn_on/off."""
referenced = await async_extract_referenced_entity_ids(opp, service)
all_referenced = referenced.referenced | referenced.indirectly_referenced
# Generic turn on/off method requires entity id
if not all_referenced:
CONF_IS_BATTERY_LEVEL,
CONF_IS_HUMIDITY,
CONF_IS_ILLUMINANCE,
CONF_IS_POWER,
CONF_IS_PRESSURE,
CONF_IS_SIGNAL_STRENGTH,
CONF_IS_TEMPERATURE,
CONF_IS_TIMESTAMP,
CONF_IS_VALUE,
]
),
vol.Optional(CONF_BELOW): vol.Any(vol.Coerce(float)),
vol.Optional(CONF_ABOVE): vol.Any(vol.Coerce(float)),
}
),
cv.has_at_least_one_key(CONF_BELOW, CONF_ABOVE),
)
async def async_get_conditions(
opp: OpenPeerPower, device_id: str
) -> List[Dict[str, str]]:
"""List device conditions."""
conditions: List[Dict[str, str]] = []
entity_registry = await async_get_registry(opp)
entries = [
entry
for entry in async_entries_for_device(entity_registry, device_id)
if entry.domain == DOMAIN
]
vol.Optional(OZW_INSTANCE, default=1):
vol.Coerce(int),
vol.Required(PARAMETER):
vol.Coerce(int),
vol.Required(VALUE):
vol.Any(
vol.All(
cv.ensure_list,
[
vol.All(
{
vol.Exclusive(ATTR_LABEL, "bit"): cv.string,
vol.Exclusive(ATTR_POSITION, "bit"): vol.Coerce(int),
vol.Required(ATTR_VALUE): bool,
},
cv.has_at_least_one_key(ATTR_LABEL, ATTR_POSITION),
)
],
),
vol.Coerce(int),
bool,
cv.string,
),
})
def websocket_set_config_parameter(opp, connection, msg):
"""Set a config parameter to a node."""
_call_util_function(opp, connection, msg, True, set_config_parameter,
msg[PARAMETER], msg[VALUE])
@websocket_api.websocket_command({
): cv.string,
vol.Optional(CONF_IP_PORT): cv.port,
vol.Optional(CONF_HUB_USERNAME): cv.string,
vol.Optional(CONF_HUB_PASSWORD): cv.string,
vol.Optional(CONF_HUB_VERSION, default=2): vol.In([1, 2]),
vol.Optional(CONF_OVERRIDE): vol.All(
cv.ensure_list_csv, [CONF_DEVICE_OVERRIDE_SCHEMA]
),
vol.Optional(CONF_X10): vol.All(
cv.ensure_list_csv, [CONF_X10_SCHEMA]
),
},
extra=vol.ALLOW_EXTRA,
required=True,
),
cv.has_at_least_one_key(CONF_PORT, CONF_HOST),
set_default_port,
)
},
extra=vol.ALLOW_EXTRA,
)
ADD_ALL_LINK_SCHEMA = vol.Schema(
{
vol.Required(SRV_ALL_LINK_GROUP): vol.Range(min=0, max=255),
vol.Required(SRV_ALL_LINK_MODE): vol.In([SRV_CONTROLLER, SRV_RESPONDER]),
}
)
vol.Optional(CONF_OFFSET, default=0):
vol.Coerce(float),
vol.Optional(CONF_MAX_TEMP, default=35):
cv.positive_int,
vol.Optional(CONF_MIN_TEMP, default=5):
cv.positive_int,
vol.Optional(CONF_STEP, default=0.5):
vol.Coerce(float),
vol.Optional(CONF_STRUCTURE, default=DEFAULT_STRUCTURE_PREFIX):
cv.string,
vol.Optional(CONF_TEMPERATURE_UNIT, default=DEFAULT_TEMP_UNIT):
cv.string,
})
COVERS_SCHEMA = vol.All(
cv.has_at_least_one_key(CALL_TYPE_COIL, CONF_REGISTER),
BASE_COMPONENT_SCHEMA.extend({
vol.Optional(CONF_DEVICE_CLASS):
COVER_DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_STATE_CLOSED, default=0):
cv.positive_int,
vol.Optional(CONF_STATE_CLOSING, default=3):
cv.positive_int,
vol.Optional(CONF_STATE_OPEN, default=1):
cv.positive_int,
vol.Optional(CONF_STATE_OPENING, default=2):
cv.positive_int,
vol.Optional(CONF_STATUS_REGISTER):
cv.positive_int,
vol.Optional(
CONF_STATUS_REGISTER_TYPE,
CONF_PROXY_PORT = "proxy_port"
CONF_TRV = "trv"
CONF_TRVS = "trvs"
DEFAULT_PROXY_PORT = 7878
DEFAULT_PROXY_IP = "127.0.0.1"
DOMAIN = "lightwave"
LIGHTWAVE_LINK = f"{DOMAIN}_link"
LIGHTWAVE_TRV_PROXY = f"{DOMAIN}_proxy"
LIGHTWAVE_TRV_PROXY_PORT = f"{DOMAIN}_proxy_port"
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema(
vol.All(
cv.has_at_least_one_key(CONF_LIGHTS, CONF_SWITCHES, CONF_TRV),
{
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_LIGHTS, default={}): {
cv.string: vol.Schema(
{vol.Required(CONF_NAME): cv.string})
},
vol.Optional(CONF_SWITCHES, default={}): {
cv.string: vol.Schema(
{vol.Required(CONF_NAME): cv.string})
},
vol.Optional(CONF_TRV, default={}): {
vol.Optional(CONF_PROXY_PORT,
default=DEFAULT_PROXY_PORT):
cv.port,
vol.Optional(CONF_PROXY_IP, default=DEFAULT_PROXY_IP):
}
)
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN: vol.Schema(
{
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_USERNAME): cv.string,
vol.Exclusive(CONF_API_KEY, "auth"): cv.string,
vol.Exclusive(CONF_PASSWORD, "auth"): cv.string,
vol.Optional(CONF_PORT, default=DEFAULT_PORT): cv.port,
vol.Optional(CONF_URLBASE, default=DEFAULT_URLBASE): urlbase,
vol.Optional(CONF_SSL, default=DEFAULT_SSL): cv.boolean,
},
cv.has_at_least_one_key("auth"),
)
},
extra=vol.ALLOW_EXTRA,
)
def setup(opp, config):
"""Set up the Ombi component platform."""
ombi = pyombi.Ombi(
ssl=config[DOMAIN][CONF_SSL],
host=config[DOMAIN][CONF_HOST],
port=config[DOMAIN][CONF_PORT],
urlbase=config[DOMAIN][CONF_URLBASE],
username=config[DOMAIN][CONF_USERNAME],
PLATFORM_SCHEMA,
BaseNotificationService,
)
from openpeerpower.const import CONTENT_TYPE_JSON
import openpeerpower.helpers.config_validation as cv
CONF_CONNECTION_STRING = "connection_string"
CONF_QUEUE_NAME = "queue"
CONF_TOPIC_NAME = "topic"
ATTR_ASB_MESSAGE = "message"
ATTR_ASB_TITLE = "title"
ATTR_ASB_TARGET = "target"
PLATFORM_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_QUEUE_NAME, CONF_TOPIC_NAME),
PLATFORM_SCHEMA.extend({
vol.Required(CONF_CONNECTION_STRING):
cv.string,
vol.Exclusive(CONF_QUEUE_NAME, "output", "Can only send to a queue or a topic."):
cv.string,
vol.Exclusive(CONF_TOPIC_NAME, "output", "Can only send to a queue or a topic."):
cv.string,
}),
)
_LOGGER = logging.getLogger(__name__)
def get_service(opp, config, discovery_info=None):
"""Get the notification service."""
def async_register(self) -> None:
"""Register all our services."""
self._opp.services.async_register(
const.DOMAIN,
const.SERVICE_SET_CONFIG_PARAMETER,
self.async_set_config_parameter,
schema=vol.Schema(
vol.All(
{
vol.Optional(ATTR_DEVICE_ID): vol.All(
cv.ensure_list, [cv.string]
),
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(const.ATTR_CONFIG_PARAMETER): vol.Any(
vol.Coerce(int), cv.string
),
vol.Optional(const.ATTR_CONFIG_PARAMETER_BITMASK): vol.Any(
vol.Coerce(int), BITMASK_SCHEMA
),
vol.Required(const.ATTR_CONFIG_VALUE): vol.Any(
vol.Coerce(int), cv.string
),
},
cv.has_at_least_one_key(ATTR_DEVICE_ID, ATTR_ENTITY_ID),
parameter_name_does_not_need_bitmask,
),
),
)
self._opp.services.async_register(
const.DOMAIN,
const.SERVICE_BULK_SET_PARTIAL_CONFIG_PARAMETERS,
self.async_bulk_set_partial_config_parameters,
schema=vol.Schema(
vol.All(
{
vol.Optional(ATTR_DEVICE_ID): vol.All(
cv.ensure_list, [cv.string]
),
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(const.ATTR_CONFIG_PARAMETER): vol.Coerce(int),
vol.Required(const.ATTR_CONFIG_VALUE): vol.Any(
vol.Coerce(int),
{
vol.Any(
vol.Coerce(int), BITMASK_SCHEMA, cv.string
): vol.Any(vol.Coerce(int), cv.string)
},
),
},
cv.has_at_least_one_key(ATTR_DEVICE_ID, ATTR_ENTITY_ID),
),
),
)
self._opp.services.async_register(
const.DOMAIN,
const.SERVICE_REFRESH_VALUE,
self.async_poll_value,
schema=vol.Schema(
{
vol.Required(ATTR_ENTITY_ID): cv.entity_ids,
vol.Optional(const.ATTR_REFRESH_ALL_VALUES, default=False): bool,
}
),
)
self._opp.services.async_register(
const.DOMAIN,
const.SERVICE_SET_VALUE,
self.async_set_value,
schema=vol.Schema(
vol.All(
{
vol.Optional(ATTR_DEVICE_ID): vol.All(
cv.ensure_list, [cv.string]
),
vol.Optional(ATTR_ENTITY_ID): cv.entity_ids,
vol.Required(const.ATTR_COMMAND_CLASS): vol.Coerce(int),
vol.Required(const.ATTR_PROPERTY): vol.Any(
vol.Coerce(int), str
),
vol.Optional(const.ATTR_PROPERTY_KEY): vol.Any(
vol.Coerce(int), str
),
vol.Optional(const.ATTR_ENDPOINT): vol.Coerce(int),
vol.Required(const.ATTR_VALUE): vol.Any(
bool, vol.Coerce(int), vol.Coerce(float), cv.string
),
vol.Optional(const.ATTR_WAIT_FOR_RESULT): vol.Coerce(bool),
},
cv.has_at_least_one_key(ATTR_DEVICE_ID, ATTR_ENTITY_ID),
),
),
)
async def async_setup(opp: OpenPeerPower, config: ConfigType) -> bool:
"""Set up an input datetime."""
component = EntityComponent(_LOGGER, DOMAIN, opp)
id_manager = collection.IDManager()
yaml_collection = collection.YamlCollection(
logging.getLogger(f"{__name__}.yaml_collection"), id_manager)
collection.sync_entity_lifecycle(opp, DOMAIN, DOMAIN, component,
yaml_collection, InputDatetime.from_yaml)
storage_collection = DateTimeStorageCollection(
Store(opp, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
id_manager,
)
collection.sync_entity_lifecycle(opp, DOMAIN, DOMAIN, component,
storage_collection, InputDatetime)
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in config.get(DOMAIN, {}).items()])
await storage_collection.async_load()
collection.StorageCollectionWebsocket(storage_collection, DOMAIN, DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS).async_setup(opp)
async def reload_service_handler(service_call: ServiceCall) -> None:
"""Reload yaml entities."""
conf = await component.async_prepare_reload(skip_reset=True)
if conf is None:
conf = {DOMAIN: {}}
await yaml_collection.async_load([{
CONF_ID: id_,
**cfg
} for id_, cfg in conf.get(DOMAIN, {}).items()])
openpeerpower.helpers.service.async_register_admin_service(
opp,
DOMAIN,
SERVICE_RELOAD,
reload_service_handler,
schema=RELOAD_SERVICE_SCHEMA,
)
component.async_register_entity_service(
"set_datetime",
vol.All(
vol.Schema(
{
vol.Optional(ATTR_DATE): cv.date,
vol.Optional(ATTR_TIME): cv.time,
vol.Optional(ATTR_DATETIME): cv.datetime,
vol.Optional(ATTR_TIMESTAMP): vol.Coerce(float),
},
extra=vol.ALLOW_EXTRA,
),
cv.has_at_least_one_key(ATTR_DATE, ATTR_TIME, ATTR_DATETIME,
ATTR_TIMESTAMP),
validate_set_datetime_attrs,
),
"async_set_datetime",
)
return True
{
DOMAIN:
vol.Schema(
{
vol.Exclusive(CONF_EVENT_HUB_CON_STRING, "setup_methods"):
cv.string,
vol.Exclusive(CONF_EVENT_HUB_NAMESPACE, "setup_methods"):
cv.string,
vol.Optional(CONF_EVENT_HUB_INSTANCE_NAME): cv.string,
vol.Optional(CONF_EVENT_HUB_SAS_POLICY): cv.string,
vol.Optional(CONF_EVENT_HUB_SAS_KEY): cv.string,
vol.Optional(CONF_SEND_INTERVAL, default=5): cv.positive_int,
vol.Optional(CONF_MAX_DELAY, default=30): cv.positive_int,
vol.Optional(CONF_FILTER, default={}): FILTER_SCHEMA,
},
cv.has_at_least_one_key(CONF_EVENT_HUB_CON_STRING,
CONF_EVENT_HUB_NAMESPACE),
)
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(opp, yaml_config):
"""Activate Azure EH component."""
config = yaml_config[DOMAIN]
if config.get(CONF_EVENT_HUB_CON_STRING):
client_args = {"conn_str": config[CONF_EVENT_HUB_CON_STRING]}
conn_str_client = True
else:
client_args = {
"fully_qualified_namespace":
raise vol.Invalid(
f"must be a value between 0 and {self.maximum}")
except ValueError as err:
raise vol.Invalid("invalid time_pattern value") from err
return value
TRIGGER_SCHEMA = vol.All(
vol.Schema({
vol.Required(CONF_PLATFORM): "time_pattern",
CONF_HOURS: TimePattern(maximum=23),
CONF_MINUTES: TimePattern(maximum=59),
CONF_SECONDS: TimePattern(maximum=59),
}),
cv.has_at_least_one_key(CONF_HOURS, CONF_MINUTES, CONF_SECONDS),
)
async def async_attach_trigger(opp, config, action, automation_info):
"""Listen for state changes based on configuration."""
trigger_id = automation_info.get("trigger_id") if automation_info else None
hours = config.get(CONF_HOURS)
minutes = config.get(CONF_MINUTES)
seconds = config.get(CONF_SECONDS)
job = OppJob(action)
# If larger units are specified, default the smaller units to zero
if minutes is None and hours is not None:
minutes = 0
if seconds is None and minutes is not None:
],
)
},
extra=vol.ALLOW_EXTRA,
)
DELETE_SMS_SCHEMA = vol.Schema(
{
vol.Optional(ATTR_HOST): cv.string,
vol.Required(ATTR_SMS_ID): vol.All(cv.ensure_list, [cv.positive_int]),
}
)
SET_OPTION_SCHEMA = vol.Schema(
vol.All(
cv.has_at_least_one_key(ATTR_FAILOVER, ATTR_AUTOCONNECT),
{
vol.Optional(ATTR_HOST): cv.string,
vol.Optional(ATTR_FAILOVER): vol.In(FAILOVER_MODES),
vol.Optional(ATTR_AUTOCONNECT): vol.In(AUTOCONNECT_MODES),
},
)
)
CONNECT_LTE_SCHEMA = vol.Schema({vol.Optional(ATTR_HOST): cv.string})
DISCONNECT_LTE_SCHEMA = vol.Schema({vol.Optional(ATTR_HOST): cv.string})
@attr.s
class ModemData:
CONF_NAME,
CONF_RESOURCE,
CONF_RESOURCE_TEMPLATE,
CONF_VALUE_TEMPLATE,
)
from openpeerpower.exceptions import PlatformNotReady
import openpeerpower.helpers.config_validation as cv
from . import async_get_config_and_coordinator, create_rest_data_from_config
from .entity import RestEntity
from .schema import BINARY_SENSOR_SCHEMA, RESOURCE_SCHEMA
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({**RESOURCE_SCHEMA, **BINARY_SENSOR_SCHEMA})
PLATFORM_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_RESOURCE, CONF_RESOURCE_TEMPLATE), PLATFORM_SCHEMA
)
async def async_setup_platform(opp, config, async_add_entities, discovery_info=None):
"""Set up the REST binary sensor."""
# Must update the sensor now (including fetching the rest resource) to
# ensure it's updating its state.
if discovery_info is not None:
conf, coordinator, rest = await async_get_config_and_coordinator(
opp, BINARY_SENSOR_DOMAIN, discovery_info
)
else:
conf = config
coordinator = None
rest = create_rest_data_from_config(opp, conf)
vol.Optional(CONF_DEPARTURE):
cv.time,
vol.Optional(CONF_NAME, default=DEFAULT_NAME):
cv.string,
vol.Optional(CONF_MODE, default=TRAVEL_MODE_CAR):
vol.In(TRAVEL_MODE),
vol.Optional(CONF_ROUTE_MODE, default=ROUTE_MODE_FASTEST):
vol.In(ROUTE_MODE),
vol.Optional(CONF_TRAFFIC_MODE, default=False):
cv.boolean,
vol.Optional(CONF_UNIT_SYSTEM):
vol.In(UNITS),
})
PLATFORM_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_DESTINATION_LATITUDE,
CONF_DESTINATION_ENTITY_ID),
cv.has_at_least_one_key(CONF_ORIGIN_LATITUDE, CONF_ORIGIN_ENTITY_ID),
cv.key_value_schemas(
CONF_MODE,
{
None:
PLATFORM_SCHEMA,
TRAVEL_MODE_BICYCLE:
PLATFORM_SCHEMA,
TRAVEL_MODE_CAR:
PLATFORM_SCHEMA,
TRAVEL_MODE_PEDESTRIAN:
PLATFORM_SCHEMA,
TRAVEL_MODE_PUBLIC:
PLATFORM_SCHEMA,
TRAVEL_MODE_TRUCK:
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,
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)
from openpeerpower.helpers import config_validation as cv, entity_platform
from .const import DOMAIN, SMARTTUB_CONTROLLER
from .entity import SmartTubSensorBase
_LOGGER = logging.getLogger(__name__)
# the desired duration, in hours, of the cycle
ATTR_DURATION = "duration"
ATTR_CYCLE_LAST_UPDATED = "cycle_last_updated"
ATTR_MODE = "mode"
# the hour of the day at which to start the cycle (0-23)
ATTR_START_HOUR = "start_hour"
SET_PRIMARY_FILTRATION_SCHEMA = vol.All(
cv.has_at_least_one_key(ATTR_DURATION, ATTR_START_HOUR),
cv.make_entity_service_schema(
{
vol.Optional(ATTR_DURATION): vol.All(int, vol.Range(min=1,
max=24)),
vol.Optional(ATTR_START_HOUR): vol.All(int, vol.Range(min=0,
max=23)),
}, ),
)
SET_SECONDARY_FILTRATION_SCHEMA = {
vol.Required(ATTR_MODE):
vol.In({
mode.name.lower()
for mode in
smarttub.SpaSecondaryFiltrationCycle.SecondaryFiltrationMode
EVENT_HANGOUTS_CONVERSATIONS_RESOLVED = "hangouts_conversations_resolved"
EVENT_HANGOUTS_MESSAGE_RECEIVED = "hangouts_message_received"
CONF_CONVERSATION_ID = "id"
CONF_CONVERSATION_NAME = "name"
SERVICE_SEND_MESSAGE = "send_message"
SERVICE_UPDATE = "update"
SERVICE_RECONNECT = "reconnect"
TARGETS_SCHEMA = vol.All(
vol.Schema({
vol.Exclusive(CONF_CONVERSATION_ID, "id or name"): cv.string,
vol.Exclusive(CONF_CONVERSATION_NAME, "id or name"): cv.string,
}),
cv.has_at_least_one_key(CONF_CONVERSATION_ID, CONF_CONVERSATION_NAME),
)
MESSAGE_SEGMENT_SCHEMA = vol.Schema({
vol.Required("text"): cv.string,
vol.Optional("is_bold"): cv.boolean,
vol.Optional("is_italic"): cv.boolean,
vol.Optional("is_strikethrough"): cv.boolean,
vol.Optional("is_underline"): cv.boolean,
vol.Optional("parse_str"): cv.boolean,
vol.Optional("link_target"): cv.string,
})
MESSAGE_DATA_SCHEMA = vol.Schema({
vol.Optional("image_file"): cv.string,
vol.Optional("image_url"): cv.string
})
),
)
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_NEW_DEVICE_DEFAULTS, default={}):
NEW_DEVICE_DEFAULTS_SCHEMA,
})
PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE.extend(PLATFORM_SCHEMA.schema)
SERVICE_SEE_PAYLOAD_SCHEMA = vol.Schema(
vol.All(
cv.has_at_least_one_key(ATTR_MAC, ATTR_DEV_ID),
{
ATTR_MAC:
cv.string,
ATTR_DEV_ID:
cv.string,
ATTR_HOST_NAME:
cv.string,
ATTR_LOCATION_NAME:
cv.string,
ATTR_GPS:
cv.gps,
ATTR_GPS_ACCURACY:
cv.positive_int,
ATTR_BATTERY:
cv.positive_int,
vol.Optional(CONF_VERIFY_REGISTER): cv.positive_int,
vol.Optional(CONF_VERIFY_STATE, default=True): cv.boolean,
}
)
COILS_SCHEMA = vol.Schema(
{
vol.Required(CONF_COIL): cv.positive_int,
vol.Required(CONF_NAME): cv.string,
vol.Required(CONF_SLAVE): cv.positive_int,
vol.Optional(CONF_HUB, default=DEFAULT_HUB): cv.string,
}
)
PLATFORM_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_COILS, CONF_REGISTERS),
PLATFORM_SCHEMA.extend(
{
vol.Optional(CONF_COILS): [COILS_SCHEMA],
vol.Optional(CONF_REGISTERS): [REGISTERS_SCHEMA],
}
),
)
def setup_platform(opp, config, add_entities, discovery_info=None):
"""Read configuration and create Modbus devices."""
switches = []
if CONF_COILS in config:
for coil in config[CONF_COILS]:
hub_name = coil[CONF_HUB]
vol.Schema(
{
vol.Optional(ENABLED): cv.boolean,
vol.Optional(LEVEL): vol.All(
cv.string,
vol.Lower,
vol.In([log_level.value for log_level in LogLevel]),
lambda val: LogLevel(val), # pylint: disable=unnecessary-lambda
),
vol.Optional(LOG_TO_FILE): cv.boolean,
vol.Optional(FILENAME): cv.string,
vol.Optional(FORCE_CONSOLE): cv.boolean,
}
),
cv.has_at_least_one_key(
ENABLED, FILENAME, FORCE_CONSOLE, LEVEL, LOG_TO_FILE
),
filename_is_present_if_logging_to_file,
),
},
)
@websocket_api.async_response
@async_get_entry
async def websocket_update_log_config(
opp: OpenPeerPower,
connection: ActiveConnection,
msg: dict,
entry: ConfigEntry,
client: Client,
) -> None:
"""Update the driver log config."""
return config
# configuration.yaml schemas (legacy)
BINARY_SENSOR_SCHEMA_YAML = vol.All(
vol.Schema(
{
vol.Exclusive(CONF_ZONE, "s_io"): ensure_zone,
vol.Exclusive(CONF_PIN, "s_io"): ensure_pin,
vol.Required(CONF_TYPE): DEVICE_CLASSES_SCHEMA,
vol.Optional(CONF_NAME): cv.string,
vol.Optional(CONF_INVERSE, default=False): cv.boolean,
}
),
cv.has_at_least_one_key(CONF_PIN, CONF_ZONE),
)
SENSOR_SCHEMA_YAML = vol.All(
vol.Schema(
{
vol.Exclusive(CONF_ZONE, "s_io"): ensure_zone,
vol.Exclusive(CONF_PIN, "s_io"): ensure_pin,
vol.Required(CONF_TYPE): vol.All(vol.Lower, vol.In(["dht", "ds18b20"])),
vol.Optional(CONF_NAME): cv.string,
vol.Optional(CONF_POLL_INTERVAL, default=3): vol.All(
vol.Coerce(int), vol.Range(min=1)
),
}
),
cv.has_at_least_one_key(CONF_PIN, CONF_ZONE),
DEFAULT_MIN_TEMP = 7
DEFAULT_MAX_TEMP = 35
DEFAULT_MIN_HUMIDITY = 30
DEFAULT_MAX_HUMIDITY = 99
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(opp: OpenPeerPower, config: ConfigType) -> bool:
"""Set up climate entities."""
)
_LOWER_STRING_LIST = vol.All(
cv.ensure_list,
[vol.All(cv.string, vol.Lower)],
vol.Length(min=1, msg="List cannot be empty"),
)
_EXCL_INCL_SLUG_LIST = vol.All(
vol.Schema(
{
vol.Exclusive(CONF_EXCLUDE, "incl_excl"): _SLUG_LIST,
vol.Exclusive(CONF_INCLUDE, "incl_excl"): _SLUG_LIST,
}
),
cv.has_at_least_one_key(CONF_EXCLUDE, CONF_INCLUDE),
_excl_incl_list_to_filter_dict,
)
_EXCL_INCL_LOWER_STRING_LIST = vol.All(
vol.Schema(
{
vol.Exclusive(CONF_EXCLUDE, "incl_excl"): _LOWER_STRING_LIST,
vol.Exclusive(CONF_INCLUDE, "incl_excl"): _LOWER_STRING_LIST,
}
),
cv.has_at_least_one_key(CONF_EXCLUDE, CONF_INCLUDE),
_excl_incl_list_to_filter_dict,
)
_THRESHOLD = vol.All(vol.Coerce(int), vol.Range(min=1))
EVENT_MATRIX_COMMAND = "matrix_command"
ATTR_IMAGES = "images" # optional images
COMMAND_SCHEMA = vol.All(
vol.Schema({
vol.Exclusive(CONF_WORD, "trigger"):
cv.string,
vol.Exclusive(CONF_EXPRESSION, "trigger"):
cv.is_regex,
vol.Required(CONF_NAME):
cv.string,
vol.Optional(CONF_ROOMS, default=[]):
vol.All(cv.ensure_list, [cv.string]),
}),
cv.has_at_least_one_key(CONF_WORD, CONF_EXPRESSION),
)
CONFIG_SCHEMA = vol.Schema(
{
DOMAIN:
vol.Schema({
vol.Required(CONF_HOMESERVER):
cv.url,
vol.Optional(CONF_VERIFY_SSL, default=True):
cv.boolean,
vol.Required(CONF_USERNAME):
cv.matches_regex("@[^:]*:.*"),
vol.Required(CONF_PASSWORD):
cv.string,
vol.Optional(CONF_ROOMS, default=[]):
def async_register(self):
"""Register all our services."""
self._opp.services.async_register(
const.DOMAIN,
const.SERVICE_ADD_NODE,
self.async_add_node,
schema=vol.Schema({
vol.Optional(const.ATTR_INSTANCE_ID, default=1):
vol.Coerce(int),
vol.Optional(const.ATTR_SECURE, default=False):
vol.Coerce(bool),
}),
)
self._opp.services.async_register(
const.DOMAIN,
const.SERVICE_REMOVE_NODE,
self.async_remove_node,
schema=vol.Schema({
vol.Optional(const.ATTR_INSTANCE_ID, default=1):
vol.Coerce(int)
}),
)
self._opp.services.async_register(
const.DOMAIN,
const.SERVICE_CANCEL_COMMAND,
self.async_cancel_command,
schema=vol.Schema({
vol.Optional(const.ATTR_INSTANCE_ID, default=1):
vol.Coerce(int)
}),
)
self._opp.services.async_register(
const.DOMAIN,
const.SERVICE_SET_CONFIG_PARAMETER,
self.async_set_config_parameter,
schema=vol.Schema({
vol.Optional(const.ATTR_INSTANCE_ID, default=1):
vol.Coerce(int),
vol.Required(const.ATTR_NODE_ID):
vol.Coerce(int),
vol.Required(const.ATTR_CONFIG_PARAMETER):
vol.Coerce(int),
vol.Required(const.ATTR_CONFIG_VALUE):
vol.Any(
vol.All(
cv.ensure_list,
[
vol.All(
{
vol.Exclusive(ATTR_LABEL, "bit"):
cv.string,
vol.Exclusive(ATTR_POSITION, "bit"):
vol.Coerce(int),
vol.Required(ATTR_VALUE):
bool,
},
cv.has_at_least_one_key(
ATTR_LABEL, ATTR_POSITION),
)
],
),
vol.Coerce(int),
bool,
cv.string,
),
}),
)
SERVICE_GET_ZWAVE_PARAMETER_SCHEMA = {
vol.Required(CONF_PARAMETER): vol.Coerce(int)
}
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,
}),
)
cv.ensure_list,
[
vol.Schema({
vol.Optional(CONF_ID): cv.string,
vol.Required(CONF_NAME): cv.string,
vol.Optional(CONF_ICON): cv.icon,
vol.Required(CONF_ENTITIES): STATES_SCHEMA,
})
],
),
},
extra=vol.ALLOW_EXTRA,
)
CREATE_SCENE_SCHEMA = vol.All(
cv.has_at_least_one_key(CONF_ENTITIES, CONF_SNAPSHOT),
_ensure_no_intersection,
vol.Schema({
vol.Required(CONF_SCENE_ID): cv.slug,
vol.Optional(CONF_ENTITIES, default={}): STATES_SCHEMA,
vol.Optional(CONF_SNAPSHOT, default=[]): cv.entity_ids,
}),
)
SERVICE_APPLY = "apply"
SERVICE_CREATE = "create"
SCENECONFIG = namedtuple("SceneConfig",
[CONF_ID, CONF_NAME, CONF_ICON, STATES])
_LOGGER = logging.getLogger(__name__)
DOMAIN = "upb"
ATTR_ADDRESS = "address"
ATTR_BLINK_RATE = "blink_rate"
ATTR_BRIGHTNESS = "brightness"
ATTR_BRIGHTNESS_PCT = "brightness_pct"
ATTR_RATE = "rate"
CONF_NETWORK = "network"
EVENT_UPB_SCENE_CHANGED = "upb.scene_changed"
VALID_BRIGHTNESS = vol.All(vol.Coerce(int), vol.Clamp(min=0, max=255))
VALID_BRIGHTNESS_PCT = vol.All(vol.Coerce(float), vol.Range(min=0, max=100))
VALID_RATE = vol.All(vol.Coerce(float), vol.Clamp(min=-1, max=3600))
UPB_BRIGHTNESS_RATE_SCHEMA = vol.All(
cv.has_at_least_one_key(ATTR_BRIGHTNESS, ATTR_BRIGHTNESS_PCT),
cv.make_entity_service_schema(
{
vol.Exclusive(ATTR_BRIGHTNESS, ATTR_BRIGHTNESS): VALID_BRIGHTNESS,
vol.Exclusive(ATTR_BRIGHTNESS_PCT, ATTR_BRIGHTNESS): VALID_BRIGHTNESS_PCT,
vol.Optional(ATTR_RATE, default=-1): VALID_RATE,
}
),
)
UPB_BLINK_RATE_SCHEMA = {
vol.Required(ATTR_BLINK_RATE, default=0.5): vol.All(
vol.Coerce(float), vol.Range(min=0, max=4.25)
)
}
