async def async_setup_entry(opp: OpenPeerPower, entry: ConfigEntry,
async_add_entities):
"""Set up for AlarmDecoder alarm panels."""
options = entry.options
arm_options = options.get(OPTIONS_ARM, DEFAULT_ARM_OPTIONS)
client = opp.data[DOMAIN][entry.entry_id][DATA_AD]
entity = AlarmDecoderAlarmPanel(
client=client,
auto_bypass=arm_options[CONF_AUTO_BYPASS],
code_arm_required=arm_options[CONF_CODE_ARM_REQUIRED],
alt_night_mode=arm_options[CONF_ALT_NIGHT_MODE],
)
async_add_entities([entity])
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_ALARM_TOGGLE_CHIME,
{
vol.Required(ATTR_CODE): cv.string,
},
"alarm_toggle_chime",
)
platform.async_register_entity_service(
SERVICE_ALARM_KEYPRESS,
{
vol.Required(ATTR_KEYPRESS): cv.string,
},
"alarm_keypress",
)
async def async_setup_platform(
opp: OpenPeerPower, config: ConfigType, async_add_entities, discovery_info=None
) -> None:
"""Set up the Genius Hub switch entities."""
if discovery_info is None:
return
broker = opp.data[DOMAIN]["broker"]
async_add_entities(
[
GeniusSwitch(broker, z)
for z in broker.client.zone_objs
if z.data["type"] == GH_ON_OFF_ZONE
]
)
# Register custom services
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SVC_SET_SWITCH_OVERRIDE,
SET_SWITCH_OVERRIDE_SCHEMA,
"async_turn_on",
)
async def async_setup_entry(opp: OpenPeerPower, entry: ConfigEntry,
async_add_entities):
"""Set up MelCloud device climate based on config_entry."""
mel_devices = opp.data[DOMAIN][entry.entry_id]
async_add_entities(
[
AtaDeviceClimate(mel_device, mel_device.device)
for mel_device in mel_devices[DEVICE_TYPE_ATA]
] + [
AtwDeviceZoneClimate(mel_device, mel_device.device, zone)
for mel_device in mel_devices[DEVICE_TYPE_ATW]
for zone in mel_device.device.zones
],
True,
)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_VANE_HORIZONTAL,
{vol.Required(CONF_POSITION): cv.string},
"async_set_vane_horizontal",
)
platform.async_register_entity_service(
SERVICE_SET_VANE_VERTICAL,
{vol.Required(CONF_POSITION): cv.string},
"async_set_vane_vertical",
)
async def async_setup_entry(
opp: OpenPeerPower,
entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
"""Set up Litter-Robot cleaner using config entry."""
hub: LitterRobotHub = opp.data[DOMAIN][entry.entry_id]
entities = []
for robot in hub.account.robots:
entities.append(
LitterRobotCleaner(robot=robot, entity_type=TYPE_LITTER_BOX, hub=hub)
)
async_add_entities(entities, True)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_RESET_WASTE_DRAWER,
{},
"async_reset_waste_drawer",
)
platform.async_register_entity_service(
SERVICE_SET_SLEEP_MODE,
{
vol.Required("enabled"): cv.boolean,
vol.Optional("start_time"): cv.time,
},
"async_set_sleep_mode",
)
platform.async_register_entity_service(
SERVICE_SET_WAIT_TIME,
{vol.Required("minutes"): vol.All(vol.Coerce(int), vol.In(VALID_WAIT_TIMES))},
"async_set_wait_time",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Create the Elk-M1 sensor platform."""
elk_data = opp.data[DOMAIN][config_entry.entry_id]
entities = []
elk = elk_data["elk"]
create_elk_entities(elk_data, elk.counters, "counter", ElkCounter, entities)
create_elk_entities(elk_data, elk.keypads, "keypad", ElkKeypad, entities)
create_elk_entities(elk_data, [elk.panel], "panel", ElkPanel, entities)
create_elk_entities(elk_data, elk.settings, "setting", ElkSetting, entities)
create_elk_entities(elk_data, elk.zones, "zone", ElkZone, entities)
async_add_entities(entities, True)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SENSOR_COUNTER_REFRESH,
{},
"async_counter_refresh",
)
platform.async_register_entity_service(
SERVICE_SENSOR_COUNTER_SET,
ELK_SET_COUNTER_SERVICE_SCHEMA,
"async_counter_set",
)
platform.async_register_entity_service(
SERVICE_SENSOR_ZONE_BYPASS,
ELK_USER_CODE_SERVICE_SCHEMA,
"async_zone_bypass",
)
platform.async_register_entity_service(
SERVICE_SENSOR_ZONE_TRIGGER,
{},
"async_zone_trigger",
)
async def async_setup_entry(opp, entry, async_add_entities):
"""Set up Hive thermostat based on a config entry."""
hive = opp.data[DOMAIN][entry.entry_id]
devices = hive.session.deviceList.get("water_heater")
entities = []
if devices:
for dev in devices:
entities.append(HiveWaterHeater(hive, dev))
async_add_entities(entities, True)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_BOOST_HOT_WATER,
{
vol.Optional(ATTR_TIME_PERIOD, default="00:30:00"): vol.All(
cv.time_period,
cv.positive_timedelta,
lambda td: td.total_seconds() // 60,
),
vol.Required(ATTR_ONOFF): vol.In(WATER_HEATER_MODES),
},
"async_hot_water_boost",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up the Rachio switches."""
zone_entities = []
has_flex_sched = False
entities = await opp.async_add_executor_job(_create_entities, opp,
config_entry)
for entity in entities:
if isinstance(entity, RachioZone):
zone_entities.append(entity)
if isinstance(entity,
RachioSchedule) and entity.type == SCHEDULE_TYPE_FLEX:
has_flex_sched = True
async_add_entities(entities)
_LOGGER.info("%d Rachio switch(es) added", len(entities))
def start_multiple(service):
"""Service to start multiple zones in sequence."""
zones_list = []
person = opp.data[DOMAIN_RACHIO][config_entry.entry_id]
entity_id = service.data[ATTR_ENTITY_ID]
duration = iter(service.data[ATTR_DURATION])
default_time = service.data[ATTR_DURATION][0]
entity_to_zone_id = {
entity.entity_id: entity.zone_id
for entity in zone_entities
}
for (count, data) in enumerate(entity_id):
if data in entity_to_zone_id:
# Time can be passed as a list per zone,
# or one time for all zones
time = int(next(duration, default_time)) * 60
zones_list.append({
ATTR_ID: entity_to_zone_id.get(data),
ATTR_DURATION: time,
ATTR_SORT_ORDER: count,
})
if len(zones_list) != 0:
person.start_multiple_zones(zones_list)
_LOGGER.debug("Starting zone(s) %s", entity_id)
else:
raise OpenPeerPowerError(
"No matching zones found in given entity_ids")
opp.services.async_register(
DOMAIN_RACHIO,
SERVICE_START_MULTIPLE_ZONES,
start_multiple,
schema=START_MULTIPLE_ZONES_SCHEMA,
)
if has_flex_sched:
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_ZONE_MOISTURE,
{vol.Required(ATTR_PERCENT): cv.positive_int},
"set_moisture_percent",
)
async def async_setup_platform(opp, config, async_add_entities, discovery_info=None):
"""Set up the Openhome platform."""
if not discovery_info:
return
openhome_data = opp.data.setdefault(DATA_OPENHOME, set())
name = discovery_info.get("name")
description = discovery_info.get("ssdp_description")
_LOGGER.info("Openhome device found: %s", name)
device = await opp.async_add_executor_job(Device, description)
await device.init()
# if device has already been discovered
if device.uuid() in openhome_data:
return True
entity = OpenhomeDevice(opp, device)
async_add_entities([entity])
openhome_data.add(device.uuid())
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_INVOKE_PIN,
{vol.Required(ATTR_PIN_INDEX): cv.positive_int},
"async_invoke_pin",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up climate for a Nexia device."""
nexia_data = opp.data[DOMAIN][config_entry.entry_id]
nexia_home = nexia_data[NEXIA_DEVICE]
coordinator = nexia_data[UPDATE_COORDINATOR]
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_HUMIDIFY_SETPOINT,
SET_HUMIDITY_SCHEMA,
SERVICE_SET_HUMIDIFY_SETPOINT,
)
platform.async_register_entity_service(SERVICE_SET_AIRCLEANER_MODE,
SET_AIRCLEANER_SCHEMA,
SERVICE_SET_AIRCLEANER_MODE)
entities = []
for thermostat_id in nexia_home.get_thermostat_ids():
thermostat = nexia_home.get_thermostat_by_id(thermostat_id)
for zone_id in thermostat.get_zone_ids():
zone = thermostat.get_zone_by_id(zone_id)
entities.append(NexiaZone(coordinator, zone))
async_add_entities(entities, True)
async def async_setup_platform(opp,
opp_config,
async_add_entities,
discovery_info=None):
"""Create the ViCare climate devices."""
if discovery_info is None:
return
vicare_api = opp.data[VICARE_DOMAIN][VICARE_API]
heating_type = opp.data[VICARE_DOMAIN][VICARE_HEATING_TYPE]
async_add_entities([
ViCareClimate(
f"{opp.data[VICARE_DOMAIN][VICARE_NAME]} Heating",
vicare_api,
heating_type,
)
])
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_VICARE_MODE,
{
vol.Required(SERVICE_SET_VICARE_MODE_ATTR_MODE):
vol.In(VICARE_TO_HA_HVAC_HEATING)
},
"set_vicare_mode",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up the Flo switches from config entry."""
devices: list[FloDeviceDataUpdateCoordinator] = opp.data[FLO_DOMAIN][
config_entry.entry_id
]["devices"]
entities = []
for device in devices:
if device.device_type != "puck_oem":
entities.append(FloSwitch(device))
async_add_entities(entities)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_AWAY_MODE, {}, "async_set_mode_away"
)
platform.async_register_entity_service(
SERVICE_SET_HOME_MODE, {}, "async_set_mode_home"
)
platform.async_register_entity_service(
SERVICE_RUN_HEALTH_TEST, {}, "async_run_health_test"
)
platform.async_register_entity_service(
SERVICE_SET_SLEEP_MODE,
{
vol.Required(ATTR_SLEEP_MINUTES, default=120): vol.In(SLEEP_MINUTE_OPTIONS),
vol.Required(ATTR_REVERT_TO_MODE, default=SYSTEM_MODE_HOME): vol.In(
SYSTEM_REVERT_MODES
),
},
"async_set_mode_sleep",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Z-Wave lock from config entry."""
@callback
def async_add_lock(value):
"""Add Z-Wave Lock."""
lock = ZWaveLock(value)
async_add_entities([lock])
opp.data[DOMAIN][config_entry.entry_id][DATA_UNSUBSCRIBE].append(
async_dispatcher_connect(opp, f"{DOMAIN}_new_{LOCK_DOMAIN}", async_add_lock)
)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_USERCODE,
{
vol.Required(ATTR_CODE_SLOT): vol.Coerce(int),
vol.Required(ATTR_USERCODE): cv.string,
},
"async_set_usercode",
)
platform.async_register_entity_service(
SERVICE_CLEAR_USERCODE,
{vol.Required(ATTR_CODE_SLOT): vol.Coerce(int)},
"async_clear_usercode",
)
async def async_setup_entry(opp, entry, async_add_entities):
"""Set up Neato vacuum with config entry."""
dev = []
neato = opp.data.get(NEATO_LOGIN)
mapdata = opp.data.get(NEATO_MAP_DATA)
persistent_maps = opp.data.get(NEATO_PERSISTENT_MAPS)
for robot in opp.data[NEATO_ROBOTS]:
dev.append(NeatoConnectedVacuum(neato, robot, mapdata, persistent_maps))
if not dev:
return
_LOGGER.debug("Adding vacuums %s", dev)
async_add_entities(dev, True)
platform = entity_platform.async_get_current_platform()
assert platform is not None
platform.async_register_entity_service(
"custom_cleaning",
{
vol.Optional(ATTR_MODE, default=2): cv.positive_int,
vol.Optional(ATTR_NAVIGATION, default=1): cv.positive_int,
vol.Optional(ATTR_CATEGORY, default=4): cv.positive_int,
vol.Optional(ATTR_ZONE): cv.string,
},
"neato_custom_cleaning",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Roon MediaPlayer from Config Entry."""
roon_server = opp.data[DOMAIN][config_entry.entry_id]
media_players = set()
# Register entity services
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_TRANSFER,
{vol.Required(ATTR_TRANSFER): cv.entity_id},
"async_transfer",
)
@callback
def async_update_media_player(player_data):
"""Add or update Roon MediaPlayer."""
dev_id = player_data["dev_id"]
if dev_id not in media_players:
# new player!
media_player = RoonDevice(roon_server, player_data)
media_players.add(dev_id)
async_add_entities([media_player])
else:
# update existing player
async_dispatcher_send(
opp, f"room_media_player_update_{dev_id}", player_data
)
# start listening for players to be added or changed by the server component
async_dispatcher_connect(opp, "roon_media_player", async_update_media_player)
async def async_setup_entry(opp: OpenPeerPower, config_entry: ConfigEntry,
async_add_entities) -> None:
"""Set up songpal media player."""
name = config_entry.data[CONF_NAME]
endpoint = config_entry.data[CONF_ENDPOINT]
device = Device(endpoint)
try:
async with async_timeout.timeout(
10): # set timeout to avoid blocking the setup process
await device.get_supported_methods()
except (SongpalException, asyncio.TimeoutError) as ex:
_LOGGER.warning("[%s(%s)] Unable to connect", name, endpoint)
_LOGGER.debug("Unable to get methods from songpal: %s", ex)
raise PlatformNotReady from ex
songpal_entity = SongpalEntity(name, device)
async_add_entities([songpal_entity], True)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SET_SOUND_SETTING,
{
vol.Required(PARAM_NAME): cv.string,
vol.Required(PARAM_VALUE): cv.string
},
"async_set_sound_setting",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up AdvantageAir sensor platform."""
instance = opp.data[ADVANTAGE_AIR_DOMAIN][config_entry.entry_id]
entities = []
for ac_key, ac_device in instance["coordinator"].data["aircons"].items():
entities.append(AdvantageAirTimeTo(instance, ac_key, "On"))
entities.append(AdvantageAirTimeTo(instance, ac_key, "Off"))
for zone_key, zone in ac_device["zones"].items():
# Only show damper sensors when zone is in temperature control
if zone["type"] != 0:
entities.append(
AdvantageAirZoneVent(instance, ac_key, zone_key))
# Only show wireless signal strength sensors when using wireless sensors
if zone["rssi"] > 0:
entities.append(
AdvantageAirZoneSignal(instance, ac_key, zone_key))
async_add_entities(entities)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
ADVANTAGE_AIR_SERVICE_SET_TIME_TO,
{vol.Required("minutes"): cv.positive_int},
"set_time_to",
)
async def async_setup_entry(opp, entry, async_add_entities):
"""Set up the Netatmo camera platform."""
if "access_camera" not in entry.data["token"]["scope"]:
_LOGGER.info(
"Cameras are currently not supported with this authentication method"
)
data_handler = opp.data[DOMAIN][entry.entry_id][DATA_HANDLER]
await data_handler.register_data_class(
CAMERA_DATA_CLASS_NAME, CAMERA_DATA_CLASS_NAME, None
)
data_class = data_handler.data.get(CAMERA_DATA_CLASS_NAME)
if not data_class or not data_class.raw_data:
raise PlatformNotReady
all_cameras = []
for home in data_class.cameras.values():
for camera in home.values():
all_cameras.append(camera)
entities = [
NetatmoCamera(
data_handler,
camera["id"],
camera["type"],
camera["home_id"],
DEFAULT_QUALITY,
)
for camera in all_cameras
]
for person_id, person_data in data_handler.data[
CAMERA_DATA_CLASS_NAME
].persons.items():
opp.data[DOMAIN][DATA_PERSONS][person_id] = person_data.get(ATTR_PSEUDO)
_LOGGER.debug("Adding cameras %s", entities)
async_add_entities(entities, True)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_PERSONS_HOME,
{vol.Required(ATTR_PERSONS): vol.All(cv.ensure_list, [cv.string])},
"_service_set_persons_home",
)
platform.async_register_entity_service(
SERVICE_SET_PERSON_AWAY,
{vol.Optional(ATTR_PERSON): cv.string},
"_service_set_person_away",
)
platform.async_register_entity_service(
SERVICE_SET_CAMERA_LIGHT,
{vol.Required(ATTR_CAMERA_LIGHT_MODE): vol.In(CAMERA_LIGHT_MODES)},
"_service_set_camera_light",
)
def async_setup_light_services(opp: OpenPeerPower):
"""Create device-specific services for the ISY Integration."""
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(SERVICE_SET_ON_LEVEL,
SERVICE_SET_VALUE_SCHEMA,
"async_set_on_level")
platform.async_register_entity_service(SERVICE_SET_RAMP_RATE,
SERVICE_SET_RAMP_RATE_SCHEMA,
"async_set_ramp_rate")
async def async_setup_platform(opp,
config,
async_add_entities,
discovery_info=None):
"""Set up the Yamaha platform."""
# Keep track of configured receivers so that we don't end up
# discovering a receiver dynamically that we have static config
# for. Map each device from its zone_id .
known_zones = opp.data.setdefault(DATA_YAMAHA, set())
# Get the Infos for configuration from config (YAML) or Discovery
config_info = YamahaConfigInfo(config=config,
discovery_info=discovery_info)
# Async check if the Receivers are there in the network
receivers = await opp.async_add_executor_job(_discovery, config_info)
entities = []
for receiver in receivers:
if receiver.zone in config_info.zone_ignore:
continue
entity = YamahaDevice(
config_info.name,
receiver,
config_info.source_ignore,
config_info.source_names,
config_info.zone_names,
)
# Only add device if it's not already added
if entity.zone_id not in known_zones:
known_zones.add(entity.zone_id)
entities.append(entity)
else:
_LOGGER.debug("Ignoring duplicate receiver: %s", config_info.name)
async_add_entities(entities)
# Register Service 'select_scene'
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SELECT_SCENE,
{vol.Required(ATTR_SCENE): cv.string},
"set_scene",
)
# Register Service 'enable_output'
platform.async_register_entity_service(
SERVICE_ENABLE_OUTPUT,
{
vol.Required(ATTR_ENABLED): cv.boolean,
vol.Required(ATTR_PORT): cv.string
},
"enable_output",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up the Monoprice 6-zone amplifier platform."""
port = config_entry.data[CONF_PORT]
monoprice = opp.data[DOMAIN][config_entry.entry_id][MONOPRICE_OBJECT]
sources = _get_sources(config_entry)
entities = []
for i in range(1, 4):
for j in range(1, 7):
zone_id = (i * 10) + j
_LOGGER.info("Adding zone %d for port %s", zone_id, port)
entities.append(
MonopriceZone(monoprice, sources, config_entry.entry_id,
zone_id))
# only call update before add if it's the first run so we can try to detect zones
first_run = opp.data[DOMAIN][config_entry.entry_id][FIRST_RUN]
async_add_entities(entities, first_run)
platform = entity_platform.async_get_current_platform()
def _call_service(entities, service_call):
for entity in entities:
if service_call.service == SERVICE_SNAPSHOT:
entity.snapshot()
elif service_call.service == SERVICE_RESTORE:
entity.restore()
@service.verify_domain_control(opp, DOMAIN)
async def async_service_handle(service_call):
"""Handle for services."""
entities = await platform.async_extract_from_service(service_call)
if not entities:
return
opp.async_add_executor_job(_call_service, entities, service_call)
opp.services.async_register(
DOMAIN,
SERVICE_SNAPSHOT,
async_service_handle,
schema=cv.make_entity_service_schema({}),
)
opp.services.async_register(
DOMAIN,
SERVICE_RESTORE,
async_service_handle,
schema=cv.make_entity_service_schema({}),
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up the Motion Blind from a config entry."""
entities = []
motion_gateway = opp.data[DOMAIN][config_entry.entry_id][KEY_GATEWAY]
coordinator = opp.data[DOMAIN][config_entry.entry_id][KEY_COORDINATOR]
for blind in motion_gateway.device_list.values():
if blind.type in POSITION_DEVICE_MAP:
entities.append(
MotionPositionDevice(coordinator, blind,
POSITION_DEVICE_MAP[blind.type],
config_entry))
elif blind.type in TILT_DEVICE_MAP:
entities.append(
MotionTiltDevice(coordinator, blind,
TILT_DEVICE_MAP[blind.type], config_entry))
elif blind.type in TDBU_DEVICE_MAP:
entities.append(
MotionTDBUDevice(coordinator, blind,
TDBU_DEVICE_MAP[blind.type], config_entry,
"Top"))
entities.append(
MotionTDBUDevice(
coordinator,
blind,
TDBU_DEVICE_MAP[blind.type],
config_entry,
"Bottom",
))
entities.append(
MotionTDBUDevice(
coordinator,
blind,
TDBU_DEVICE_MAP[blind.type],
config_entry,
"Combined",
))
else:
_LOGGER.warning("Blind type '%s' not yet supported",
blind.blind_type)
async_add_entities(entities)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_ABSOLUTE_POSITION,
SET_ABSOLUTE_POSITION_SCHEMA,
SERVICE_SET_ABSOLUTE_POSITION,
)
async def async_setup_entry(opp, config, async_add_entities):
"""Set up a Blink Camera."""
data = opp.data[DOMAIN][config.entry_id]
entities = [
BlinkCamera(data, name, camera)
for name, camera in data.cameras.items()
]
async_add_entities(entities)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(SERVICE_TRIGGER, {},
"trigger_camera")
async def async_setup_entry(opp, entry, async_add_entities):
"""Set up the Roku config entry."""
coordinator = opp.data[DOMAIN][entry.entry_id]
unique_id = coordinator.data.info.serial_number
async_add_entities([RokuMediaPlayer(unique_id, coordinator)], True)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SEARCH,
SEARCH_SCHEMA,
"search",
)
async def async_setup_entry(opp, entry, async_add_entities):
"""Set up the Netatmo energy platform."""
data_handler = opp.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 or home_data.raw_data == {}:
raise PlatformNotReady
if HOMEDATA_DATA_CLASS_NAME not in data_handler.data:
raise PlatformNotReady
entities = []
for home_id in get_all_home_ids(home_data):
for room_id in home_data.rooms[home_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))
opp.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())
}
opp.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())
}
_LOGGER.debug("Adding climate devices %s", entities)
async_add_entities(entities, True)
platform = entity_platform.async_get_current_platform()
if home_data is not None:
platform.async_register_entity_service(
SERVICE_SET_SCHEDULE,
{vol.Required(ATTR_SCHEDULE_NAME): cv.string},
"_async_service_set_schedule",
)
async def async_setup_platform(
opp: OpenPeerPower,
config: dict,
async_add_entities: AddEntitiesCallback,
discovery_info: dict,
) -> None:
"""Set up the switcher platform for the switch component."""
if discovery_info is None:
return
async def async_set_auto_off_service(entity,
service_call: ServiceCall) -> None:
"""Use for handling setting device auto-off service calls."""
async with SwitcherV2Api(
opp.loop,
device_data.ip_addr,
device_data.phone_id,
device_data.device_id,
device_data.device_password,
) as swapi:
await swapi.set_auto_shutdown(service_call.data[CONF_AUTO_OFF])
async def async_turn_on_with_timer_service(
entity, service_call: ServiceCall) -> None:
"""Use for handling turning device on with a timer service calls."""
async with SwitcherV2Api(
opp.loop,
device_data.ip_addr,
device_data.phone_id,
device_data.device_id,
device_data.device_password,
) as swapi:
await swapi.control_device(COMMAND_ON,
service_call.data[CONF_TIMER_MINUTES])
device_data = opp.data[DOMAIN][DATA_DEVICE]
async_add_entities([SwitcherControl(opp.data[DOMAIN][DATA_DEVICE])])
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_SET_AUTO_OFF_NAME,
SERVICE_SET_AUTO_OFF_SCHEMA,
async_set_auto_off_service,
)
platform.async_register_entity_service(
SERVICE_TURN_ON_WITH_TIMER_NAME,
SERVICE_TURN_ON_WITH_TIMER_SCHEMA,
async_turn_on_with_timer_service,
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up the Risco alarm control panel."""
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(SERVICE_BYPASS_ZONE, {},
"async_bypass_zone")
platform.async_register_entity_service(SERVICE_UNBYPASS_ZONE, {},
"async_unbypass_zone")
coordinator = opp.data[DOMAIN][config_entry.entry_id][DATA_COORDINATOR]
entities = [
RiscoBinarySensor(coordinator, zone_id, zone)
for zone_id, zone in coordinator.data.zones.items()
]
async_add_entities(entities, False)
async def async_setup_platform(opp,
config,
async_add_entities,
discovery_info=None):
"""Set up the Dyson fan components."""
if discovery_info is None:
return
_LOGGER.debug("Creating new Dyson fans")
if DYSON_FAN_DEVICES not in opp.data:
opp.data[DYSON_FAN_DEVICES] = []
# Get Dyson Devices from parent component
has_purecool_devices = False
device_serials = [device.serial for device in opp.data[DYSON_FAN_DEVICES]]
for device in opp.data[DYSON_DEVICES]:
if device.serial not in device_serials:
if isinstance(device, DysonPureCool):
has_purecool_devices = True
dyson_entity = DysonPureCoolEntity(device)
opp.data[DYSON_FAN_DEVICES].append(dyson_entity)
elif isinstance(device, DysonPureCoolLink):
dyson_entity = DysonPureCoolLinkEntity(device)
opp.data[DYSON_FAN_DEVICES].append(dyson_entity)
async_add_entities(opp.data[DYSON_FAN_DEVICES])
# Register custom services
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(SERVICE_SET_NIGHT_MODE,
SET_NIGHT_MODE_SCHEMA,
"set_night_mode")
platform.async_register_entity_service(SERVICE_SET_AUTO_MODE,
SET_AUTO_MODE_SCHEMA,
"set_auto_mode")
platform.async_register_entity_service(SERVICE_SET_DYSON_SPEED,
SET_DYSON_SPEED_SCHEMA,
"service_set_dyson_speed")
if has_purecool_devices:
platform.async_register_entity_service(SERVICE_SET_ANGLE,
SET_ANGLE_SCHEMA, "set_angle")
platform.async_register_entity_service(
SERVICE_SET_FLOW_DIRECTION_FRONT,
SET_FLOW_DIRECTION_FRONT_SCHEMA,
"set_flow_direction_front",
)
platform.async_register_entity_service(SERVICE_SET_TIMER,
SET_TIMER_SCHEMA, "set_timer")
async def async_setup_entry(opp, entry, async_add_entities):
"""Set up Hive thermostat based on a config entry."""
hive = opp.data[DOMAIN][entry.entry_id]
devices = hive.session.deviceList.get("climate")
entities = []
if devices:
for dev in devices:
entities.append(HiveClimateEntity(hive, dev))
async_add_entities(entities, True)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
"boost_heating",
{
vol.Required(ATTR_TIME_PERIOD):
vol.All(
cv.time_period,
cv.positive_timedelta,
lambda td: td.total_seconds() // 60,
),
vol.Optional(ATTR_TEMPERATURE, default="25.0"):
vol.Coerce(float),
},
"async_heating_boost",
)
platform.async_register_entity_service(
SERVICE_BOOST_HEATING_ON,
{
vol.Required(ATTR_TIME_PERIOD):
vol.All(
cv.time_period,
cv.positive_timedelta,
lambda td: td.total_seconds() // 60,
),
vol.Optional(ATTR_TEMPERATURE, default="25.0"):
vol.Coerce(float),
},
"async_heating_boost_on",
)
platform.async_register_entity_service(
SERVICE_BOOST_HEATING_OFF,
{},
"async_heating_boost_off",
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up the Zigbee Home Automation Door Lock from config entry."""
entities_to_create = opp.data[DATA_ZHA][DOMAIN]
unsub = async_dispatcher_connect(
opp,
SIGNAL_ADD_ENTITIES,
functools.partial(discovery.async_add_entities, async_add_entities,
entities_to_create),
)
opp.data[DATA_ZHA][DATA_ZHA_DISPATCHERS].append(unsub)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service( # type: ignore
SERVICE_SET_LOCK_USER_CODE,
{
vol.Required("code_slot"): vol.Coerce(int),
vol.Required("user_code"): cv.string,
},
"async_set_lock_user_code",
)
platform.async_register_entity_service( # type: ignore
SERVICE_ENABLE_LOCK_USER_CODE,
{
vol.Required("code_slot"): vol.Coerce(int),
},
"async_enable_lock_user_code",
)
platform.async_register_entity_service( # type: ignore
SERVICE_DISABLE_LOCK_USER_CODE,
{
vol.Required("code_slot"): vol.Coerce(int),
},
"async_disable_lock_user_code",
)
platform.async_register_entity_service( # type: ignore
SERVICE_CLEAR_LOCK_USER_CODE,
{
vol.Required("code_slot"): vol.Coerce(int),
},
"async_clear_lock_user_code",
)
async def async_setup_entry(opp: OpenPeerPower, entry: ConfigEntry,
async_add_entities):
"""Set up the Tado water heater platform."""
tado = opp.data[DOMAIN][entry.entry_id][DATA]
entities = await opp.async_add_executor_job(_generate_entities, tado)
platform = entity_platform.async_get_current_platform()
platform.async_register_entity_service(
SERVICE_WATER_HEATER_TIMER,
WATER_HEATER_TIMER_SCHEMA,
"set_timer",
)
if entities:
async_add_entities(entities, True)
