async def async_added_to_opp(self):
"""Connect camera methods to signals."""
def _dispatch_proxy(method):
"""Expand parameters & filter entity IDs."""
async def _call(params):
entity_ids = params.get(ATTR_ENTITY_ID)
filtered_params = {
k: v
for k, v in params.items() if k != ATTR_ENTITY_ID
}
if entity_ids is None or self.entity_id in entity_ids:
await method(**filtered_params)
return _call
self._listeners.extend([
async_dispatcher_connect(
self.opp,
SIGNAL_LOGI_CIRCLE_RECONFIGURE,
_dispatch_proxy(self.set_config),
),
async_dispatcher_connect(
self.opp,
SIGNAL_LOGI_CIRCLE_SNAPSHOT,
_dispatch_proxy(self.livestream_snapshot),
),
async_dispatcher_connect(
self.opp,
SIGNAL_LOGI_CIRCLE_RECORD,
_dispatch_proxy(self.download_livestream),
),
])
async def async_added_to_opp(self):
"""Add device to dict."""
async_dispatcher_connect(
self.opp,
SIGNAL_REFRESH_ENTITY_FORMAT.format(self.entity_id),
self.refresh_from_network,
)
async def async_added_to_opp(self):
"""Register update callback."""
# Remove temporary bogus entity_id if added
tmp_entity = TMP_ENTITY.format(self._device_id)
if (tmp_entity in self.opp.data[DATA_ENTITY_LOOKUP][EVENT_KEY_SENSOR][
self._device_id]):
self.opp.data[DATA_ENTITY_LOOKUP][EVENT_KEY_SENSOR][
self._device_id].remove(tmp_entity)
# Register id and aliases
self.opp.data[DATA_ENTITY_LOOKUP][EVENT_KEY_SENSOR][
self._device_id].append(self.entity_id)
if self._aliases:
for _id in self._aliases:
self.opp.data[DATA_ENTITY_LOOKUP][EVENT_KEY_SENSOR][
_id].append(self.entity_id)
self.async_on_remove(
async_dispatcher_connect(self.opp, SIGNAL_AVAILABILITY,
self._availability_callback))
self.async_on_remove(
async_dispatcher_connect(
self.opp,
SIGNAL_HANDLE_EVENT.format(self.entity_id),
self.handle_event_callback,
))
# Process the initial event now that the entity is created
if self._initial_event:
self.handle_event_callback(self._initial_event)
async def test_internal_discovery_callback_fill_out_group(opp):
"""Test internal discovery automatically filling out information."""
discover_cast, _, _ = await async_setup_cast_internal_discovery(opp)
info = get_fake_chromecast_info(host="host1", port=12345)
zconf = get_fake_zconf(host="host1", port=12345)
full_info = attr.evolve(
info,
model_name="",
friendly_name="Speaker",
uuid=FakeUUID,
is_dynamic_group=False,
)
with patch(
"openpeerpower.components.cast.helpers.dial.get_device_status",
return_value=full_info,
), patch(
"openpeerpower.components.cast.discovery.ChromeCastZeroconf.get_zeroconf",
return_value=zconf,
):
signal = MagicMock()
async_dispatcher_connect(opp, "cast_discovered", signal)
discover_cast("the-service", info)
await opp.async_block_till_done()
# when called with incomplete info, it should use HTTP to get missing
discover = signal.mock_calls[0][1][0]
assert discover == full_info
async def async_added_to_opp(self):
"""Store entity_id and register state change callback."""
entity_id_key = self._addr or self._type
self._data[entity_id_key] = self.entity_id
async_dispatcher_connect(self.opp,
f"konnected.{self.entity_id}.update",
self.async_set_state)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Cast from a config entry."""
opp.data.setdefault(ADDED_CAST_DEVICES_KEY, set())
# Import CEC IGNORE attributes
pychromecast.IGNORE_CEC += config_entry.data.get(CONF_IGNORE_CEC) or []
wanted_uuids = config_entry.data.get(CONF_UUID) or None
@callback
def async_cast_discovered(discover: ChromecastInfo) -> None:
"""Handle discovery of a new chromecast."""
# If wanted_uuids is set, we're only accepting specific cast devices identified
# by UUID
if wanted_uuids is not None and discover.uuid not in wanted_uuids:
# UUID not matching, ignore.
return
cast_device = _async_create_cast_device(opp, discover)
if cast_device is not None:
async_add_entities([cast_device])
async_dispatcher_connect(opp, SIGNAL_CAST_DISCOVERED,
async_cast_discovered)
ChromeCastZeroconf.set_zeroconf(await zeroconf.async_get_instance(opp))
opp.async_add_executor_job(setup_internal_discovery, opp, config_entry)
async def async_added_to_opp(self):
"""Connect and subscribe to dispatcher signals and state updates."""
async_dispatcher_connect(self.opp, DOMAIN, self.async_signal_handler)
await self._client.register_state_update_callback(
self.async_handle_state_update
)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up device tracker for Mikrotik component."""
hub = opp.data[DOMAIN][config_entry.entry_id]
tracked = {}
registry = await entity_registry.async_get_registry(opp)
# Restore clients that is not a part of active clients list.
for entity in registry.entities.values():
if (entity.config_entry_id == config_entry.entry_id
and entity.domain == DEVICE_TRACKER):
if (entity.unique_id in hub.api.devices
or entity.unique_id not in hub.api.all_devices):
continue
hub.api.restore_device(entity.unique_id)
@callback
def update_hub():
"""Update the status of the device."""
update_items(hub, async_add_entities, tracked)
async_dispatcher_connect(opp, hub.signal_update, update_hub)
update_hub()
async def async_setup_entry(opp, entry, async_add_entities):
"""Set up Plaato from a config entry."""
entry_data = opp.data[DOMAIN][entry.entry_id]
@callback
async def _async_update_from_webhook(device_id, sensor_data: PlaatoDevice):
"""Update/Create the sensors."""
entry_data[SENSOR_DATA] = sensor_data
if device_id != entry_data[DEVICE][DEVICE_ID]:
entry_data[DEVICE][DEVICE_ID] = device_id
async_add_entities([
PlaatoSensor(entry_data, sensor_type)
for sensor_type in sensor_data.sensors
])
else:
for sensor_type in sensor_data.sensors:
async_dispatcher_send(opp,
SENSOR_SIGNAL % (device_id, sensor_type))
if entry.data[CONF_USE_WEBHOOK]:
async_dispatcher_connect(opp, SENSOR_UPDATE,
_async_update_from_webhook)
else:
coordinator = entry_data[COORDINATOR]
async_add_entities(
PlaatoSensor(entry_data, sensor_type, coordinator)
for sensor_type in coordinator.data.sensors)
async def async_added_to_opp(self) -> None:
"""Handle common setup when added to opp."""
await self.speaker.async_seen()
self.async_on_remove(
async_dispatcher_connect(
self.opp,
f"{SONOS_POLL_UPDATE}-{self.soco.uid}",
self.async_poll,
)
)
self.async_on_remove(
async_dispatcher_connect(
self.opp,
f"{SONOS_STATE_UPDATED}-{self.soco.uid}",
self.async_write_op_state,
)
)
self.async_on_remove(
async_dispatcher_connect(
self.opp,
f"{SONOS_HOUSEHOLD_UPDATED}-{self.soco.household_id}",
self.async_write_op_state,
)
)
async_dispatcher_send(
self.opp, f"{SONOS_ENTITY_CREATED}-{self.soco.uid}", self.platform.domain
)
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 test_internal_discovery_callback_fill_out(opp):
"""Test internal discovery automatically filling out information."""
import pychromecast # imports mock pychromecast
pychromecast.ChromecastConnectionError = IOError
discover_cast, _ = await async_setup_cast_internal_discovery(opp)
info = get_fake_chromecast_info(uuid=None)
full_info = attr.evolve(info,
model_name="google home",
friendly_name="Speaker",
uuid=FakeUUID)
with patch(
"openpeerpower.components.cast.helpers.dial.get_device_status",
return_value=full_info,
):
signal = MagicMock()
async_dispatcher_connect(opp, "cast_discovered", signal)
discover_cast("the-service", info)
await opp.async_block_till_done()
# when called with incomplete info, it should use HTTP to get missing
discover = signal.mock_calls[0][1][0]
assert discover == full_info
async def test_update_device(opp):
"""Test that update works."""
host = "1.2.3.4"
entry = MockConfigEntry(domain=dynalite.DOMAIN,
data={dynalite.CONF_HOST: host})
entry.add_to_opp(opp)
with patch("openpeerpower.components.dynalite.bridge.DynaliteDevices"
) as mock_dyn_dev:
mock_dyn_dev().async_setup = AsyncMock(return_value=True)
assert await opp.config_entries.async_setup(entry.entry_id)
# Not waiting so it add the devices before registration
update_device_func = mock_dyn_dev.mock_calls[1][2][
"update_device_func"]
device = Mock()
device.unique_id = "abcdef"
wide_func = Mock()
async_dispatcher_connect(opp, f"dynalite-update-{host}", wide_func)
specific_func = Mock()
async_dispatcher_connect(opp, f"dynalite-update-{host}-{device.unique_id}",
specific_func)
update_device_func()
await opp.async_block_till_done()
wide_func.assert_called_once()
specific_func.assert_not_called()
update_device_func(device)
await opp.async_block_till_done()
wide_func.assert_called_once()
specific_func.assert_called_once()
async def async_setup_scanner(opp, config, async_see, discovery_info=None):
"""Set up the MySensors device scanner."""
new_devices = mysensors.setup_mysensors_platform(
opp,
DOMAIN,
discovery_info,
MySensorsDeviceScanner,
device_args=(opp, async_see),
)
if not new_devices:
return False
for device in new_devices:
gateway_id = id(device.gateway)
dev_id = (gateway_id, device.node_id, device.child_id, device.value_type)
async_dispatcher_connect(
opp,
mysensors.const.CHILD_CALLBACK.format(*dev_id),
device.async_update_callback,
)
async_dispatcher_connect(
opp,
mysensors.const.NODE_CALLBACK.format(gateway_id, device.node_id),
device.async_update_callback,
)
return True
def async_subscribe_connection_status(opp, connection_status_callback):
"""Subscribe to MQTT connection changes."""
connection_status_callback_job = OppJob(connection_status_callback)
async def connected():
task = opp.async_run_opp_job(connection_status_callback_job, True)
if task:
await task
async def disconnected():
task = opp.async_run_opp_job(connection_status_callback_job, False)
if task:
await task
subscriptions = {
"connect":
async_dispatcher_connect(opp, MQTT_CONNECTED, connected),
"disconnect":
async_dispatcher_connect(opp, MQTT_DISCONNECTED, disconnected),
}
@callback
def unsubscribe():
subscriptions["connect"]()
subscriptions["disconnect"]()
return unsubscribe
async def async_added_to_opp(self):
"""Call when entity is added to opp."""
self._remove_signal_delete = async_dispatcher_connect(
self.opp, f"gdacs_delete_{self._external_id}",
self._delete_callback)
self._remove_signal_update = async_dispatcher_connect(
self.opp, f"gdacs_update_{self._external_id}",
self._update_callback)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Z-Wave Fan from Config Entry."""
@callback
def async_add_fan(fan):
"""Add Z-Wave Fan."""
async_add_entities([fan])
async_dispatcher_connect(opp, "zwave_new_fan", async_add_fan)
def __init__(self, opp, addr, name):
"""Register callback that will be used for signals."""
self._opp = opp
self._addr = addr
self._name = name
self._id = slugify(self._name)
signal = f"homeworks_entity_{self._addr}"
async_dispatcher_connect(self._opp, signal, self._update_callback)
async def async_added_to_opp(self):
"""Connect to the OpenTherm Gateway device."""
_LOGGER.debug("Added OpenTherm Gateway climate device %s",
self.friendly_name)
self._unsub_updates = async_dispatcher_connect(
self.opp, self._gateway.update_signal, self.receive_report)
self._unsub_options = async_dispatcher_connect(
self.opp, self._gateway.options_update_signal, self.update_options)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Z-Wave Light from Config Entry."""
@callback
def async_add_light(light):
"""Add Z-Wave Light."""
async_add_entities([light])
async_dispatcher_connect(opp, "zwave_new_light", async_add_light)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Z-Wave Climate device from Config Entry."""
@callback
def async_add_climate(climate):
"""Add Z-Wave Climate Device."""
async_add_entities([climate])
async_dispatcher_connect(opp, "zwave_new_climate", async_add_climate)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Z-Wave Cover from Config Entry."""
@callback
def async_add_cover(cover):
"""Add Z-Wave Cover."""
async_add_entities([cover])
async_dispatcher_connect(opp, "zwave_new_cover", async_add_cover)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Z-Wave Switch from Config Entry."""
@callback
def async_add_switch(switch):
"""Add Z-Wave Switch."""
async_add_entities([switch])
async_dispatcher_connect(opp, "zwave_new_switch", async_add_switch)
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up Z-Wave binary sensors from Config Entry."""
@callback
def async_add_binary_sensor(binary_sensor):
"""Add Z-Wave binary sensor."""
async_add_entities([binary_sensor])
async_dispatcher_connect(opp, "zwave_new_binary_sensor",
async_add_binary_sensor)
async def async_accept_signal(self, channel, signal, func, signal_override=False):
"""Accept a signal from a channel."""
unsub = None
if signal_override:
unsub = async_dispatcher_connect(self.opp, signal, func)
else:
unsub = async_dispatcher_connect(
self.opp, f"{channel.unique_id}_{signal}", func
)
self._unsubs.append(unsub)
async def async_added_to_opp(self):
"""Call when entity is added to opp."""
self.opp.data[DOMAIN]["entities"][self.object_id] = self.entity_id
self.async_on_remove(
async_dispatcher_connect(self.opp, SIGNAL_DELETE_ENTITY,
self._delete_callback))
self.async_on_remove(
async_dispatcher_connect(self.opp, SIGNAL_UPDATE_ENTITY,
self._update_callback))
self._inc_device_count()
async def async_added_to_opp(self) -> None:
"""Subscribe MQTT events."""
await super().async_added_to_opp()
await self._availability_subscribe_topics()
self.async_on_remove(
async_dispatcher_connect(self.opp, MQTT_CONNECTED,
self.async_mqtt_connect))
self.async_on_remove(
async_dispatcher_connect(self.opp, MQTT_DISCONNECTED,
self.async_mqtt_connect))
async def async_setup_entry(opp, config_entry, async_add_entities):
"""Set up a Point's alarm_control_panel based on a config entry."""
async def async_discover_home(home_id):
"""Discover and add a discovered home."""
client = opp.data[POINT_DOMAIN][config_entry.entry_id]
async_add_entities([MinutPointAlarmControl(client, home_id)], True)
async_dispatcher_connect(opp,
POINT_DISCOVERY_NEW.format(DOMAIN, POINT_DOMAIN),
async_discover_home)
async def test_empty_integrations_list_is_only_sent_at_the_end_of_bootstrap(
opp):
"""Test empty integrations list is only sent at the end of bootstrap."""
order = []
def gen_domain_setup(domain):
async def async_setup(opp, config):
order.append(domain)
await asyncio.sleep(0.1)
async def _background_task():
await asyncio.sleep(0.2)
await opp.async_create_task(_background_task())
return True
return async_setup
mock_integration(
opp,
MockModule(
domain="normal_integration",
async_setup=gen_domain_setup("normal_integration"),
partial_manifest={"after_dependencies": ["an_after_dep"]},
),
)
mock_integration(
opp,
MockModule(
domain="an_after_dep",
async_setup=gen_domain_setup("an_after_dep"),
),
)
integrations = []
@core.callback
def _bootstrap_integrations(data):
integrations.append(data)
async_dispatcher_connect(opp, SIGNAL_BOOTSTRAP_INTEGRATONS,
_bootstrap_integrations)
with patch.object(bootstrap, "SLOW_STARTUP_CHECK_INTERVAL", 0.05):
await bootstrap._async_set_up_integrations(opp, {
"normal_integration": {},
"an_after_dep": {}
})
assert integrations[0] != {}
assert "an_after_dep" in integrations[0]
assert integrations[-3] != {}
assert integrations[-1] == {}
assert "normal_integration" in opp.config.components
assert order == ["an_after_dep", "normal_integration"]
async def trace_action(opp, script_run, stop, variables):
"""Trace action execution."""
path = trace_path_get()
trace_element = action_trace_append(variables, path)
trace_stack_push(trace_stack_cv, trace_element)
trace_id = trace_id_get()
if trace_id:
key = trace_id[0]
run_id = trace_id[1]
breakpoints = opp.data[DATA_SCRIPT_BREAKPOINTS]
if key in breakpoints and (
(run_id in breakpoints[key] and
(path in breakpoints[key][run_id]
or NODE_ANY in breakpoints[key][run_id])) or
(RUN_ID_ANY in breakpoints[key] and
(path in breakpoints[key][RUN_ID_ANY]
or NODE_ANY in breakpoints[key][RUN_ID_ANY]))):
async_dispatcher_send(opp, SCRIPT_BREAKPOINT_HIT, key, run_id,
path)
done = asyncio.Event()
@callback
def async_continue_stop(command=None):
if command == "stop":
stop.set()
done.set()
signal = SCRIPT_DEBUG_CONTINUE_STOP.format(key, run_id)
remove_signal1 = async_dispatcher_connect(opp, signal,
async_continue_stop)
remove_signal2 = async_dispatcher_connect(
opp, SCRIPT_DEBUG_CONTINUE_ALL, async_continue_stop)
tasks = [
opp.async_create_task(flag.wait()) for flag in (stop, done)
]
await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
for task in tasks:
task.cancel()
remove_signal1()
remove_signal2()
try:
yield trace_element
except _StopScript as ex:
trace_element.set_error(ex.__cause__ or ex)
raise ex
except Exception as ex:
trace_element.set_error(ex)
raise ex
finally:
trace_stack_pop(trace_stack_cv)
