async def async_setup_entry(hass, entry, async_add_entities): """Set up the Netatmo energy platform.""" data_handler = hass.data[DOMAIN][entry.entry_id][DATA_HANDLER] await data_handler.register_data_class(HOMEDATA_DATA_CLASS_NAME, HOMEDATA_DATA_CLASS_NAME, None) home_data = data_handler.data.get(HOMEDATA_DATA_CLASS_NAME) if not home_data: return async def get_entities(): """Retrieve Netatmo entities.""" entities = [] for home_id in get_all_home_ids(home_data): _LOGGER.debug("Setting up home %s ...", home_id) for room_id in home_data.rooms[home_id].keys(): room_name = home_data.rooms[home_id][room_id]["name"] _LOGGER.debug("Setting up room %s (%s) ...", room_name, room_id) signal_name = f"{HOMESTATUS_DATA_CLASS_NAME}-{home_id}" await data_handler.register_data_class( HOMESTATUS_DATA_CLASS_NAME, signal_name, None, home_id=home_id) home_status = data_handler.data.get(signal_name) if home_status and room_id in home_status.rooms: entities.append( NetatmoThermostat(data_handler, home_id, room_id)) hass.data[DOMAIN][DATA_SCHEDULES][home_id] = { schedule_id: schedule_data.get("name") for schedule_id, schedule_data in ( data_handler.data[HOMEDATA_DATA_CLASS_NAME]. schedules[home_id].items()) } hass.data[DOMAIN][DATA_HOMES] = { home_id: home_data.get("name") for home_id, home_data in ( data_handler.data[HOMEDATA_DATA_CLASS_NAME].homes.items()) } return entities async_add_entities(await get_entities(), True) platform = entity_platform.current_platform.get() if home_data is not None: platform.async_register_entity_service( SERVICE_SETSCHEDULE, { vol.Required(ATTR_ENTITY_ID): cv.entity_domain(CLIMATE_DOMAIN), vol.Required(ATTR_SCHEDULE_NAME): cv.string, }, "_service_set_schedule", )
def test_entity_domain(): """Test entity domain validation.""" schema = vol.Schema(cv.entity_domain("sensor")) for value in ("invalid_entity", "cover.demo"): with pytest.raises(vol.MultipleInvalid): schema(value) assert schema("sensor.LIGHT") == "sensor.light" schema = vol.Schema(cv.entity_domain(("sensor", "binary_sensor"))) for value in ("invalid_entity", "cover.demo"): with pytest.raises(vol.MultipleInvalid): schema(value) assert schema("sensor.LIGHT") == "sensor.light" assert schema("binary_sensor.LIGHT") == "binary_sensor.light"
def test_entity_domain(): """Test entity domain validation.""" schema = vol.Schema(cv.entity_domain("sensor")) options = ("invalid_entity", "cover.demo") for value in options: with pytest.raises(vol.MultipleInvalid): print(value) schema(value) assert schema("sensor.LIGHT") == "sensor.light"
def test_entity_domain(): """Test entity domain validation.""" schema = vol.Schema(cv.entity_domain('sensor')) options = ( 'invalid_entity', 'cover.demo', ) for value in options: with pytest.raises(vol.MultipleInvalid): print(value) schema(value) assert schema('sensor.LIGHT') == 'sensor.light'
def test_entity_domain(): """Test entity domain validation.""" schema = vol.Schema(cv.entity_domain('sensor')) options = ( 'invalid_entity', 'cover.demo', ) for value in options: with pytest.raises(vol.MultipleInvalid): print(value) schema(value) assert schema('sensor.LIGHT') == 'sensor.light'
from homeassistant.core import callback from homeassistant.helpers import config_validation as cv from homeassistant.helpers.event import ( async_track_point_in_time, async_track_state_change_event, async_track_time_change, ) import homeassistant.util.dt as dt_util # mypy: allow-untyped-defs, no-check-untyped-defs _LOGGER = logging.getLogger(__name__) _TIME_TRIGGER_SCHEMA = vol.Any( cv.time, vol.All(str, cv.entity_domain("input_datetime")), msg="Expected HH:MM, HH:MM:SS or Entity ID from domain 'input_datetime'", ) TRIGGER_SCHEMA = vol.Schema({ vol.Required(CONF_PLATFORM): "time", vol.Required(CONF_AT): vol.All(cv.ensure_list, [_TIME_TRIGGER_SCHEMA]), }) async def async_attach_trigger(hass, config, action, automation_info): """Listen for state changes based on configuration.""" entities = {} removes = []
VIDEO_CODEC_LIBX264, ) _LOGGER = logging.getLogger(__name__) MAX_PORT = 65535 VALID_VIDEO_CODECS = [ VIDEO_CODEC_LIBX264, VIDEO_CODEC_H264_OMX, AUDIO_CODEC_COPY ] VALID_AUDIO_CODECS = [AUDIO_CODEC_OPUS, VIDEO_CODEC_COPY] BASIC_INFO_SCHEMA = vol.Schema({ vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_LINKED_BATTERY_SENSOR): cv.entity_domain(sensor.DOMAIN), vol.Optional(CONF_LOW_BATTERY_THRESHOLD, default=DEFAULT_LOW_BATTERY_THRESHOLD): cv.positive_int, }) FEATURE_SCHEMA = BASIC_INFO_SCHEMA.extend( {vol.Optional(CONF_FEATURE_LIST, default=None): cv.ensure_list}) CAMERA_SCHEMA = BASIC_INFO_SCHEMA.extend({ vol.Optional(CONF_STREAM_ADDRESS): vol.All(ipaddress.ip_address, cv.string), vol.Optional(CONF_STREAM_SOURCE): cv.string, vol.Optional(CONF_AUDIO_CODEC, default=DEFAULT_AUDIO_CODEC): vol.In(VALID_AUDIO_CODECS),
ATTR_CONFIDENCE = "confidence" ATTR_FACES = "faces" ATTR_GENDER = "gender" ATTR_GLASSES = "glasses" ATTR_MOTION = "motion" ATTR_TOTAL_FACES = "total_faces" CONF_SOURCE = "source" CONF_CONFIDENCE = "confidence" DEFAULT_TIMEOUT = 10 DEFAULT_CONFIDENCE = 80 SOURCE_SCHEMA = vol.Schema({ vol.Required(CONF_ENTITY_ID): cv.entity_domain("camera"), vol.Optional(CONF_NAME): cv.string, }) PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({ vol.Optional(CONF_SOURCE): vol.All(cv.ensure_list, [SOURCE_SCHEMA]), vol.Optional(CONF_CONFIDENCE, default=DEFAULT_CONFIDENCE): vol.All(vol.Coerce(float), vol.Range(min=0, max=100)), }) PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE.extend(PLATFORM_SCHEMA.schema) async def async_setup(hass, config): """Set up the image processing."""
TYPE_VALVE, VIDEO_CODEC_COPY, VIDEO_CODEC_H264_OMX, VIDEO_CODEC_LIBX264, ) _LOGGER = logging.getLogger(__name__) MAX_PORT = 65535 VALID_VIDEO_CODECS = [VIDEO_CODEC_LIBX264, VIDEO_CODEC_H264_OMX, AUDIO_CODEC_COPY] VALID_AUDIO_CODECS = [AUDIO_CODEC_OPUS, VIDEO_CODEC_COPY] BASIC_INFO_SCHEMA = vol.Schema( { vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_LINKED_BATTERY_SENSOR): cv.entity_domain(sensor.DOMAIN), vol.Optional(CONF_LINKED_BATTERY_CHARGING_SENSOR): cv.entity_domain( binary_sensor.DOMAIN ), vol.Optional( CONF_LOW_BATTERY_THRESHOLD, default=DEFAULT_LOW_BATTERY_THRESHOLD ): cv.positive_int, } ) FEATURE_SCHEMA = BASIC_INFO_SCHEMA.extend( {vol.Optional(CONF_FEATURE_LIST, default=None): cv.ensure_list} ) CAMERA_SCHEMA = BASIC_INFO_SCHEMA.extend( {
import voluptuous as vol from .utils import async_get_device_entries from .const import DOMAIN NO_THUMBNAIL = "vod_no_thumbnail" HAS_THUMBNAIL = "vod_has_thumbnail" CONDITION_TYPES = {NO_THUMBNAIL, HAS_THUMBNAIL} CONDITION_SCHEMA = cv.DEVICE_CONDITION_BASE_SCHEMA.extend({ vol.Required(CONF_TYPE): vol.In(CONDITION_TYPES), vol.Required(CONF_ENTITY_ID): cv.entity_domain(SENSOR_DOMAIN), }) _LOGGER = logging.getLogger(__name__) async def async_get_conditions(hass: HomeAssistant, device_id: str): """List device conditions for devices.""" conditions = [] (device, device_entries) = await async_get_device_entries(hass, device_id) if not device or not device_entries or len(device_entries) < 1: return conditions
from homeassistant.const import ( ATTR_ENTITY_ID, CONF_ENTITY_ID, CONF_NAME, STATE_ON, STATE_UNAVAILABLE) from homeassistant.core import State, callback import homeassistant.helpers.config_validation as cv from homeassistant.helpers.event import async_track_state_change from homeassistant.helpers.typing import ConfigType, HomeAssistantType from homeassistant.components.light import PLATFORM_SCHEMA, Light _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'Light Switch' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_ENTITY_ID): cv.entity_domain(switch.DOMAIN) }) async def async_setup_platform(hass: HomeAssistantType, config: ConfigType, async_add_entities, discovery_info=None) -> None: """Initialize Light Switch platform.""" async_add_entities([LightSwitch(config.get(CONF_NAME), config[CONF_ENTITY_ID])], True) class LightSwitch(Light): """Represents a Switch as a Light.""" def __init__(self, name: str, switch_entity_id: str) -> None:
ACTION_TYPES = { SERVICE_CLEAR_LOCK_USERCODE, SERVICE_PING, SERVICE_REFRESH_VALUE, SERVICE_RESET_METER, SERVICE_SET_CONFIG_PARAMETER, SERVICE_SET_LOCK_USERCODE, SERVICE_SET_VALUE, } CLEAR_LOCK_USERCODE_SCHEMA = cv.DEVICE_ACTION_BASE_SCHEMA.extend({ vol.Required(CONF_TYPE): SERVICE_CLEAR_LOCK_USERCODE, vol.Required(CONF_ENTITY_ID): cv.entity_domain(LOCK_DOMAIN), vol.Required(ATTR_CODE_SLOT): vol.Coerce(int), }) PING_SCHEMA = cv.DEVICE_ACTION_BASE_SCHEMA.extend({ vol.Required(CONF_TYPE): SERVICE_PING, }) REFRESH_VALUE_SCHEMA = cv.DEVICE_ACTION_BASE_SCHEMA.extend({ vol.Required(CONF_TYPE): SERVICE_REFRESH_VALUE, vol.Required(CONF_ENTITY_ID): cv.entity_id, vol.Optional(ATTR_REFRESH_ALL_VALUES, default=False):
from homeassistant.const import (CONF_EVENT, CONF_PLATFORM, CONF_SOURCE, CONF_ZONE, EVENT_STATE_CHANGED) from homeassistant.helpers import (condition, config_validation as cv) from homeassistant.helpers.config_validation import entity_domain EVENT_ENTER = 'enter' EVENT_LEAVE = 'leave' DEFAULT_EVENT = EVENT_ENTER TRIGGER_SCHEMA = vol.Schema({ vol.Required(CONF_PLATFORM): 'geo_location', vol.Required(CONF_SOURCE): cv.string, vol.Required(CONF_ZONE): entity_domain('zone'), vol.Required(CONF_EVENT, default=DEFAULT_EVENT): vol.Any(EVENT_ENTER, EVENT_LEAVE), }) def source_match(state, source): """Check if the state matches the provided source.""" return state and state.attributes.get('source') == source async def async_trigger(hass, config, action, automation_info): """Listen for state changes based on configuration.""" source = config.get(CONF_SOURCE).lower() zone_entity_id = config.get(CONF_ZONE) trigger_event = config.get(CONF_EVENT)
from homeassistant.helpers.event import async_track_state_change_event from homeassistant.helpers.typing import ( ConfigType, DiscoveryInfoType, HomeAssistantType, ) # mypy: allow-untyped-calls, allow-untyped-defs, no-check-untyped-defs DEFAULT_NAME = "Light Switch" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_ENTITY_ID): cv.entity_domain(switch.DOMAIN), }) async def async_setup_platform( hass: HomeAssistantType, config: ConfigType, async_add_entities: Callable[[Sequence[Entity], bool], None], discovery_info: Optional[DiscoveryInfoType] = None, ) -> None: """Initialize Light Switch platform.""" registry = await hass.helpers.entity_registry.async_get_registry() wrapped_switch = registry.async_get(config[CONF_ENTITY_ID]) unique_id = wrapped_switch.unique_id if wrapped_switch else None
vol.Required(CONF_FILTER_NAME): FILTER_NAME_THROTTLE, vol.Optional(CONF_FILTER_WINDOW_SIZE, default=DEFAULT_WINDOW_SIZE): vol.Coerce(int), }) FILTER_TIME_THROTTLE_SCHEMA = FILTER_SCHEMA.extend({ vol.Required(CONF_FILTER_NAME): FILTER_NAME_TIME_THROTTLE, vol.Required(CONF_FILTER_WINDOW_SIZE): vol.All(cv.time_period, cv.positive_timedelta), }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Required(CONF_ENTITY_ID): vol.Any(cv.entity_domain(SENSOR_DOMAIN), cv.entity_domain(BINARY_SENSOR_DOMAIN)), vol.Optional(CONF_NAME): cv.string, vol.Required(CONF_FILTERS): vol.All( cv.ensure_list, [ vol.Any( FILTER_OUTLIER_SCHEMA, FILTER_LOWPASS_SCHEMA, FILTER_TIME_SMA_SCHEMA, FILTER_THROTTLE_SCHEMA, FILTER_TIME_THROTTLE_SCHEMA, FILTER_RANGE_SCHEMA, )
import homeassistant.helpers.config_validation as cv import homeassistant.util.temperature as temp_util from .const import ( CONF_FEATURE, CONF_FEATURE_LIST, CONF_LINKED_BATTERY_SENSOR, CONF_LOW_BATTERY_THRESHOLD, DEFAULT_LOW_BATTERY_THRESHOLD, FEATURE_ON_OFF, FEATURE_PLAY_PAUSE, FEATURE_PLAY_STOP, FEATURE_TOGGLE_MUTE, HOMEKIT_NOTIFY_ID, TYPE_FAUCET, TYPE_OUTLET, TYPE_SHOWER, TYPE_SPRINKLER, TYPE_SWITCH, TYPE_VALVE) _LOGGER = logging.getLogger(__name__) BASIC_INFO_SCHEMA = vol.Schema({ vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_LINKED_BATTERY_SENSOR): cv.entity_domain(sensor.DOMAIN), vol.Optional(CONF_LOW_BATTERY_THRESHOLD, default=DEFAULT_LOW_BATTERY_THRESHOLD): cv.positive_int, }) FEATURE_SCHEMA = BASIC_INFO_SCHEMA.extend({ vol.Optional(CONF_FEATURE_LIST, default=None): cv.ensure_list, }) CODE_SCHEMA = BASIC_INFO_SCHEMA.extend({ vol.Optional(ATTR_CODE, default=None): vol.Any(None, cv.string), }) MEDIA_PLAYER_SCHEMA = vol.Schema({ vol.Required(CONF_FEATURE): vol.All( cv.string, vol.In((FEATURE_ON_OFF, FEATURE_PLAY_PAUSE,
CONF_COMFORT_TEMP = "comfort_temp" CONF_ANTI_FREEZE_TEMP = "anti_freeze_temp" CONF_TARGET_TEMP = "target_temp" SUPPORT_AWAY_TEMP = 1 SUPPORT_ECO_TEMP = 2 SUPPORT_COMFORT_TEMP = 4 SUPPORT_ANTI_FREEZE_TEMP = 8 PRESET_ANTI_FREEZE = "Anti Freeze" SENSOR_SCHEMA = vol.Schema({ vol.Required(CONF_NAME): cv.string, vol.Required(CONF_ENTITY_ID): cv.entity_domain("sensor"), vol.Optional(CONF_AWAY_TEMP): vol.Coerce(float), vol.Optional(CONF_ECO_TEMP): vol.Coerce(float), vol.Optional(CONF_COMFORT_TEMP): vol.Coerce(float), vol.Optional(CONF_ANTI_FREEZE_TEMP): vol.Coerce(float), vol.Optional(CONF_TARGET_TEMP): vol.Coerce(float) }) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( {vol.Required(CONF_SENSORS): vol.All(cv.ensure_list, [SENSOR_SCHEMA])})
from homeassistant.helpers.config_validation import entity_domain from homeassistant.helpers.event import TrackStates, async_track_state_change_filtered # mypy: allow-untyped-defs, no-check-untyped-defs EVENT_ENTER = "enter" EVENT_LEAVE = "leave" DEFAULT_EVENT = EVENT_ENTER TRIGGER_SCHEMA = vol.Schema({ vol.Required(CONF_PLATFORM): "geo_location", vol.Required(CONF_SOURCE): cv.string, vol.Required(CONF_ZONE): entity_domain("zone"), vol.Required(CONF_EVENT, default=DEFAULT_EVENT): vol.Any(EVENT_ENTER, EVENT_LEAVE), }) def source_match(state, source): """Check if the state matches the provided source.""" return state and state.attributes.get("source") == source async def async_attach_trigger(hass, config, action, automation_info): """Listen for state changes based on configuration.""" source = config.get(CONF_SOURCE).lower() zone_entity_id = config.get(CONF_ZONE) trigger_event = config.get(CONF_EVENT)
DFLT_ICON_WAIT = 'mdi:timer-sand' DFLT_ICON_OFF = 'mdi:water-off' DFLT_ICON = 'mdi:fountain' CONFIG_SCHEMA = vol.Schema( { DOMAIN: vol.Schema({ vol.Required(ATTR_ZONES): [{ vol.Required(ATTR_IRRIG_ID): cv.string, vol.Required(ATTR_WATER): vol.Range(min=1, max=30), vol.Optional(ATTR_WAIT): vol.Range(min=1, max=30), vol.Optional(ATTR_REPEAT): vol.Range(min=1, max=30), vol.Optional(ATTR_TEMPLATE): cv.template, vol.Required(ATTR_SWITCH): cv.entity_domain('switch'), vol.Optional(ATTR_ICON_WATER, default=DFLT_ICON_WATER): cv.icon, vol.Optional(ATTR_ICON_WAIT, default=DFLT_ICON_WAIT): cv.icon, vol.Optional(ATTR_ICON_OFF, default=DFLT_ICON_OFF): cv.icon, }], vol.Required(ATTR_PROGRAMS): [{ vol.Required(ATTR_IRRIG_ID): cv.string, vol.Required(ATTR_TEMPLATE): cv.template, vol.Optional(ATTR_ICON, default=DFLT_ICON): cv.icon, vol.Required(ATTR_ZONES): [{ vol.Required(ATTR_ZONE): cv.entity_domain('irrigation_zone'),
from homeassistant.core import CALLBACK_TYPE, HomeAssistant from homeassistant.helpers import config_validation as cv, entity_registry from homeassistant.helpers.trigger import TriggerActionType, TriggerInfo from homeassistant.helpers.typing import ConfigType from .const import DOMAIN TRIGGER_TYPES: Final[set[str]] = {"enters", "leaves"} TRIGGER_SCHEMA: Final = DEVICE_TRIGGER_BASE_SCHEMA.extend({ vol.Required(CONF_ENTITY_ID): cv.entity_id, vol.Required(CONF_TYPE): vol.In(TRIGGER_TYPES), vol.Required(CONF_ZONE): cv.entity_domain(DOMAIN_ZONE), }) async def async_get_triggers(hass: HomeAssistant, device_id: str) -> list[dict[str, str]]: """List device triggers for Device Tracker devices.""" registry = entity_registry.async_get(hass) triggers = [] # Get all the integrations entities for this device for entry in entity_registry.async_entries_for_device(registry, device_id): if entry.domain != DOMAIN: continue triggers.append({
HOMEKIT_PAIRING_QR_SECRET, TYPE_FAUCET, TYPE_OUTLET, TYPE_SHOWER, TYPE_SPRINKLER, TYPE_SWITCH, TYPE_VALVE, ) _LOGGER = logging.getLogger(__name__) BASIC_INFO_SCHEMA = vol.Schema( { vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_LINKED_BATTERY_SENSOR): cv.entity_domain(sensor.DOMAIN), vol.Optional( CONF_LOW_BATTERY_THRESHOLD, default=DEFAULT_LOW_BATTERY_THRESHOLD ): cv.positive_int, } ) FEATURE_SCHEMA = BASIC_INFO_SCHEMA.extend( {vol.Optional(CONF_FEATURE_LIST, default=None): cv.ensure_list} ) CODE_SCHEMA = BASIC_INFO_SCHEMA.extend( {vol.Optional(ATTR_CODE, default=None): vol.Any(None, cv.string)} ) MEDIA_PLAYER_SCHEMA = vol.Schema(
ATTR_CONFIDENCE = 'confidence' ATTR_FACES = 'faces' ATTR_GENDER = 'gender' ATTR_GLASSES = 'glasses' ATTR_MOTION = 'motion' ATTR_TOTAL_FACES = 'total_faces' CONF_SOURCE = 'source' CONF_CONFIDENCE = 'confidence' DEFAULT_TIMEOUT = 10 DEFAULT_CONFIDENCE = 80 SOURCE_SCHEMA = vol.Schema({ vol.Required(CONF_ENTITY_ID): cv.entity_domain('camera'), vol.Optional(CONF_NAME): cv.string, }) PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({ vol.Optional(CONF_SOURCE): vol.All(cv.ensure_list, [SOURCE_SCHEMA]), vol.Optional(CONF_CONFIDENCE, default=DEFAULT_CONFIDENCE): vol.All(vol.Coerce(float), vol.Range(min=0, max=100)), }) PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE.extend(PLATFORM_SCHEMA.schema) SERVICE_SCAN_SCHEMA = vol.Schema({ vol.Optional(ATTR_ENTITY_ID): cv.comp_entity_ids,
) from homeassistant.core import Event, HomeAssistant, callback from homeassistant.helpers import entity_registry as er import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.event import async_track_state_change_event from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType from .const import DOMAIN as SWITCH_DOMAIN DEFAULT_NAME = "Light Switch" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_ENTITY_ID): cv.entity_domain(SWITCH_DOMAIN), } ) async def async_setup_platform( hass: HomeAssistant, config: ConfigType, async_add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Initialize Light Switch platform.""" registry = er.async_get(hass) wrapped_switch = registry.async_get(config[CONF_ENTITY_ID]) unique_id = wrapped_switch.unique_id if wrapped_switch else None
STATE_UNKNOWN, ) from homeassistant.core import HassJob, callback from homeassistant.helpers import config_validation as cv from homeassistant.helpers.event import ( async_track_point_in_time, async_track_state_change_event, async_track_time_change, ) import homeassistant.util.dt as dt_util # mypy: allow-untyped-defs, no-check-untyped-defs _TIME_TRIGGER_SCHEMA = vol.Any( cv.time, vol.All(str, cv.entity_domain(["input_datetime", "sensor"])), msg= "Expected HH:MM, HH:MM:SS or Entity ID with domain 'input_datetime' or 'sensor'", ) TRIGGER_SCHEMA = cv.TRIGGER_BASE_SCHEMA.extend({ vol.Required(CONF_PLATFORM): "time", vol.Required(CONF_AT): vol.All(cv.ensure_list, [_TIME_TRIGGER_SCHEMA]), }) async def async_attach_trigger(hass, config, action, automation_info): """Listen for state changes based on configuration.""" trigger_data = automation_info.get("trigger_data",
VIDEO_CODEC_LIBX264, ) _LOGGER = logging.getLogger(__name__) MAX_PORT = 65535 VALID_VIDEO_CODECS = [ VIDEO_CODEC_LIBX264, VIDEO_CODEC_H264_OMX, AUDIO_CODEC_COPY ] VALID_AUDIO_CODECS = [AUDIO_CODEC_OPUS, VIDEO_CODEC_COPY] BASIC_INFO_SCHEMA = vol.Schema({ vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_LINKED_BATTERY_SENSOR): cv.entity_domain(sensor.DOMAIN), vol.Optional(CONF_LINKED_BATTERY_CHARGING_SENSOR): cv.entity_domain(binary_sensor.DOMAIN), vol.Optional(CONF_LOW_BATTERY_THRESHOLD, default=DEFAULT_LOW_BATTERY_THRESHOLD): cv.positive_int, }) FEATURE_SCHEMA = BASIC_INFO_SCHEMA.extend( {vol.Optional(CONF_FEATURE_LIST, default=None): cv.ensure_list}) CAMERA_SCHEMA = BASIC_INFO_SCHEMA.extend({ vol.Optional(CONF_STREAM_ADDRESS): vol.All(ipaddress.ip_address, cv.string), vol.Optional(CONF_STREAM_SOURCE): cv.string,
from homeassistant.core import Event, HomeAssistant, callback from homeassistant.helpers import entity_registry as er import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.event import async_track_state_change_event from homeassistant.helpers.typing import ConfigType, DiscoveryInfoType from .const import DOMAIN as SWITCH_DOMAIN DEFAULT_NAME = "Light Switch" PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_ENTITY_ID): cv.entity_domain(SWITCH_DOMAIN), }) async def async_setup_platform( hass: HomeAssistant, config: ConfigType, async_add_entities: AddEntitiesCallback, discovery_info: DiscoveryInfoType | None = None, ) -> None: """Initialize Light Switch platform.""" registry = er.async_get(hass) wrapped_switch = registry.async_get(config[CONF_ENTITY_ID]) unique_id = wrapped_switch.unique_id if wrapped_switch else None async_add_entities(
CONF_TYPE, CONF_ZONE, ) from homeassistant.core import CALLBACK_TYPE, HomeAssistant from homeassistant.helpers import config_validation as cv, entity_registry from homeassistant.helpers.typing import ConfigType from . import DOMAIN TRIGGER_TYPES = {"enters", "leaves"} TRIGGER_SCHEMA = TRIGGER_BASE_SCHEMA.extend( { vol.Required(CONF_ENTITY_ID): cv.entity_id, vol.Required(CONF_TYPE): vol.In(TRIGGER_TYPES), vol.Required(CONF_ZONE): cv.entity_domain(DOMAIN_ZONE), } ) async def async_get_triggers(hass: HomeAssistant, device_id: str) -> list[dict]: """List device triggers for Device Tracker devices.""" registry = await entity_registry.async_get_registry(hass) triggers = [] # Get all the integrations entities for this device for entry in entity_registry.async_entries_for_device(registry, device_id): if entry.domain != DOMAIN: continue triggers.append(
DOMAIN = "mqtt_climate_sync" CONF_TOPIC = "topic" EVENT_STATE_CHANGED = "mqtt_climate_sync_state_changed" CONFIG_SCHEMA = vol.Schema( { DOMAIN: vol.All( cv.ensure_list, [ vol.Schema({ vol.Required(CONF_ENTITY_ID): cv.entity_domain(CLIMATE_DOMAIN), vol.Required(CONF_TOPIC): valid_subscribe_topic, }) ], ) }, extra=vol.ALLOW_EXTRA, ) _LOGGER = logging.getLogger(__name__) async def async_setup(hass, config): """Setup the mqtt_climate_sync component.""" mqtt = hass.components.mqtt
from homeassistant.components.geo_location import DOMAIN from homeassistant.core import callback from homeassistant.const import ( CONF_EVENT, CONF_PLATFORM, CONF_SOURCE, CONF_ZONE, EVENT_STATE_CHANGED) from homeassistant.helpers import ( condition, config_validation as cv) from homeassistant.helpers.config_validation import entity_domain EVENT_ENTER = 'enter' EVENT_LEAVE = 'leave' DEFAULT_EVENT = EVENT_ENTER TRIGGER_SCHEMA = vol.Schema({ vol.Required(CONF_PLATFORM): 'geo_location', vol.Required(CONF_SOURCE): cv.string, vol.Required(CONF_ZONE): entity_domain('zone'), vol.Required(CONF_EVENT, default=DEFAULT_EVENT): vol.Any(EVENT_ENTER, EVENT_LEAVE), }) def source_match(state, source): """Check if the state matches the provided source.""" return state and state.attributes.get('source') == source async def async_trigger(hass, config, action): """Listen for state changes based on configuration.""" source = config.get(CONF_SOURCE).lower() zone_entity_id = config.get(CONF_ZONE) trigger_event = config.get(CONF_EVENT)
ATTR_CONFIDENCE = "confidence" ATTR_FACES = "faces" ATTR_GENDER = "gender" ATTR_GLASSES = "glasses" ATTR_MOTION = "motion" ATTR_TOTAL_FACES = "total_faces" CONF_SOURCE = "source" CONF_CONFIDENCE = "confidence" DEFAULT_TIMEOUT = 10 DEFAULT_CONFIDENCE = 80 SOURCE_SCHEMA = vol.Schema( { vol.Required(CONF_ENTITY_ID): cv.entity_domain("camera"), vol.Optional(CONF_NAME): cv.string, } ) PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend( { vol.Optional(CONF_SOURCE): vol.All(cv.ensure_list, [SOURCE_SCHEMA]), vol.Optional(CONF_CONFIDENCE, default=DEFAULT_CONFIDENCE): vol.All( vol.Coerce(float), vol.Range(min=0, max=100) ), } ) PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE.extend(PLATFORM_SCHEMA.schema)
ATTR_AGE = 'age' ATTR_CONFIDENCE = 'confidence' ATTR_FACES = 'faces' ATTR_GENDER = 'gender' ATTR_GLASSES = 'glasses' ATTR_MOTION = 'motion' ATTR_TOTAL_FACES = 'total_faces' CONF_SOURCE = 'source' CONF_CONFIDENCE = 'confidence' DEFAULT_TIMEOUT = 10 DEFAULT_CONFIDENCE = 80 SOURCE_SCHEMA = vol.Schema({ vol.Required(CONF_ENTITY_ID): cv.entity_domain('camera'), vol.Optional(CONF_NAME): cv.string, }) PLATFORM_SCHEMA = cv.PLATFORM_SCHEMA.extend({ vol.Optional(CONF_SOURCE): vol.All(cv.ensure_list, [SOURCE_SCHEMA]), vol.Optional(CONF_CONFIDENCE, default=DEFAULT_CONFIDENCE): vol.All(vol.Coerce(float), vol.Range(min=0, max=100)), }) PLATFORM_SCHEMA_BASE = cv.PLATFORM_SCHEMA_BASE.extend(PLATFORM_SCHEMA.schema) SERVICE_SCAN_SCHEMA = vol.Schema({ vol.Optional(ATTR_ENTITY_ID): cv.comp_entity_ids, })
) from homeassistant.core import Context, HomeAssistant from homeassistant.exceptions import HomeAssistantError from homeassistant.helpers import entity_registry import homeassistant.helpers.config_validation as cv from homeassistant.helpers.entity import get_capability, get_supported_features from . import DOMAIN, const ACTION_TYPES = {"set_hvac_mode", "set_preset_mode"} SET_HVAC_MODE_SCHEMA = cv.DEVICE_ACTION_BASE_SCHEMA.extend({ vol.Required(CONF_TYPE): "set_hvac_mode", vol.Required(CONF_ENTITY_ID): cv.entity_domain(DOMAIN), vol.Required(const.ATTR_HVAC_MODE): vol.In(const.HVAC_MODES), }) SET_PRESET_MODE_SCHEMA = cv.DEVICE_ACTION_BASE_SCHEMA.extend({ vol.Required(CONF_TYPE): "set_preset_mode", vol.Required(CONF_ENTITY_ID): cv.entity_domain(DOMAIN), vol.Required(const.ATTR_PRESET_MODE): str, }) ACTION_SCHEMA = vol.Any(SET_HVAC_MODE_SCHEMA, SET_PRESET_MODE_SCHEMA)
from homeassistant.const import ( ATTR_ENTITY_ID, CONF_ENTITY_ID, CONF_NAME, STATE_ON, STATE_UNAVAILABLE) from homeassistant.core import State, callback import homeassistant.helpers.config_validation as cv from homeassistant.helpers.event import async_track_state_change from homeassistant.helpers.typing import ConfigType, HomeAssistantType from homeassistant.components.light import PLATFORM_SCHEMA, Light _LOGGER = logging.getLogger(__name__) DEFAULT_NAME = 'Light Switch' PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({ vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string, vol.Required(CONF_ENTITY_ID): cv.entity_domain(switch.DOMAIN) }) async def async_setup_platform(hass: HomeAssistantType, config: ConfigType, async_add_entities, discovery_info=None) -> None: """Initialize Light Switch platform.""" async_add_entities([LightSwitch(config.get(CONF_NAME), config[CONF_ENTITY_ID])], True) class LightSwitch(Light): """Represents a Switch as a Light.""" def __init__(self, name: str, switch_entity_id: str) -> None:
} ) FILTER_TIME_THROTTLE_SCHEMA = FILTER_SCHEMA.extend( { vol.Required(CONF_FILTER_NAME): FILTER_NAME_TIME_THROTTLE, vol.Required(CONF_FILTER_WINDOW_SIZE): vol.All( cv.time_period, cv.positive_timedelta ), } ) PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( { vol.Required(CONF_ENTITY_ID): vol.Any( cv.entity_domain(SENSOR_DOMAIN), cv.entity_domain(BINARY_SENSOR_DOMAIN), cv.entity_domain(INPUT_NUMBER_DOMAIN), ), vol.Optional(CONF_NAME): cv.string, vol.Required(CONF_FILTERS): vol.All( cv.ensure_list, [ vol.Any( FILTER_OUTLIER_SCHEMA, FILTER_LOWPASS_SCHEMA, FILTER_TIME_SMA_SCHEMA, FILTER_THROTTLE_SCHEMA, FILTER_TIME_THROTTLE_SCHEMA, FILTER_RANGE_SCHEMA, )
ATTR_ENTITY_ID, CONF_DEVICE_ID, CONF_DOMAIN, CONF_ENTITY_ID, CONF_TYPE, ) from homeassistant.core import Context, HomeAssistant from homeassistant.helpers import entity_registry import homeassistant.helpers.config_validation as cv from . import DOMAIN, const SET_HUMIDITY_SCHEMA = cv.DEVICE_ACTION_BASE_SCHEMA.extend( { vol.Required(CONF_TYPE): "set_humidity", vol.Required(CONF_ENTITY_ID): cv.entity_domain(DOMAIN), vol.Required(const.ATTR_HUMIDITY): vol.Coerce(int), } ) SET_MODE_SCHEMA = cv.DEVICE_ACTION_BASE_SCHEMA.extend( { vol.Required(CONF_TYPE): "set_mode", vol.Required(CONF_ENTITY_ID): cv.entity_domain(DOMAIN), vol.Required(const.ATTR_MODE): cv.string, } ) ONOFF_SCHEMA = toggle_entity.ACTION_SCHEMA.extend({vol.Required(CONF_DOMAIN): DOMAIN}) ACTION_SCHEMA = vol.Any(SET_HUMIDITY_SCHEMA, SET_MODE_SCHEMA, ONOFF_SCHEMA)