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)
