def __init__( self, opp, device_id, friendly_name, state_template, icon_template, entity_picture_template, availability_template, on_action, off_action, unique_id, ): """Initialize the Template switch.""" super().__init__( availability_template=availability_template, icon_template=icon_template, entity_picture_template=entity_picture_template, ) self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id, opp=opp) self._name = friendly_name self._template = state_template domain = __name__.split(".")[-2] self._on_script = Script(opp, on_action, friendly_name, domain) self._off_script = Script(opp, off_action, friendly_name, domain) self._state = False self._unique_id = unique_id
def __init__(self, opp, object_id, cfg, raw_config, blueprint_inputs): """Initialize the script.""" self.object_id = object_id self.icon = cfg.get(CONF_ICON) self.description = cfg[CONF_DESCRIPTION] self.fields = cfg[CONF_FIELDS] self.entity_id = ENTITY_ID_FORMAT.format(object_id) self.script = Script( opp, cfg[CONF_SEQUENCE], cfg.get(CONF_ALIAS, object_id), DOMAIN, running_description="script sequence", change_listener=self.async_change_listener, script_mode=cfg[CONF_MODE], max_runs=cfg[CONF_MAX], max_exceeded=cfg[CONF_MAX_EXCEEDED], logger=logging.getLogger(f"{__name__}.{object_id}"), variables=cfg.get(CONF_VARIABLES), ) self._changed = asyncio.Event() self._raw_config = raw_config self._trace_config = cfg[CONF_TRACE] self._blueprint_inputs = blueprint_inputs
async def async_setup_entry(opp, entry, async_add_entities): """Set up the Samsung TV from a config entry.""" bridge = opp.data[DOMAIN][entry.entry_id] host = entry.data[CONF_HOST] on_script = None data = opp.data[DOMAIN] if turn_on_action := data.get(host, {}).get(CONF_ON_ACTION): on_script = Script( opp, turn_on_action, entry.data.get(CONF_NAME, DEFAULT_NAME), DOMAIN )
def __init__( self, opp, name, value_template, availability_template, command_lock, command_unlock, optimistic, unique_id, ): """Initialize the lock.""" super().__init__(availability_template=availability_template) self._state = None self._name = name self._state_template = value_template domain = __name__.split(".")[-2] self._command_lock = Script(opp, command_lock, name, domain) self._command_unlock = Script(opp, command_unlock, name, domain) self._optimistic = optimistic self._unique_id = unique_id
def __init__( self, opp, device_id, name, state_template, disarm_action, arm_away_action, arm_home_action, arm_night_action, code_arm_required, unique_id, ): """Initialize the panel.""" super().__init__() self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id, opp=opp) self._name = name self._template = state_template self._disarm_script = None self._code_arm_required = code_arm_required domain = __name__.split(".")[-2] if disarm_action is not None: self._disarm_script = Script(opp, disarm_action, name, domain) self._arm_away_script = None if arm_away_action is not None: self._arm_away_script = Script(opp, arm_away_action, name, domain) self._arm_home_script = None if arm_home_action is not None: self._arm_home_script = Script(opp, arm_home_action, name, domain) self._arm_night_script = None if arm_night_action is not None: self._arm_night_script = Script(opp, arm_night_action, name, domain) self._state = None self._unique_id = unique_id
async def handle_execute_script(opp: OpenPeerPower, connection: ActiveConnection, msg: dict[str, Any]) -> None: """Handle execute script command.""" # Circular dep # pylint: disable=import-outside-toplevel from openpeerpower.helpers.script import Script context = connection.context(msg) script_obj = Script(opp, msg["sequence"], f"{const.DOMAIN} script", const.DOMAIN) await script_obj.async_run(msg.get("variables"), context=context) connection.send_message( messages.result_message(msg["id"], {"context": context}))
def __init__( self, opp, name, host, mac_address, off_action, broadcast_address, broadcast_port, ): """Initialize the WOL switch.""" self._opp = opp self._name = name self._host = host self._mac_address = mac_address self._broadcast_address = broadcast_address self._broadcast_port = broadcast_port domain = __name__.split(".")[-2] self._off_script = Script(opp, off_action, name, domain) if off_action else None self._state = False self._assumed_state = host is None self._unique_id = dr.format_mac(mac_address)
def setup_platform(opp, config, add_entities, discovery_info=None): """Set up the LG TV platform.""" host = config.get(CONF_HOST) access_token = config.get(CONF_ACCESS_TOKEN) name = config.get(CONF_NAME) on_action = config.get(CONF_ON_ACTION) client = LgNetCastClient(host, access_token) domain = __name__.split(".")[-2] on_action_script = Script(opp, on_action, name, domain) if on_action else None add_entities([LgTVDevice(client, name, on_action_script)], True)
async def async_setup_platform(opp, config, async_add_entities, discovery_info=None): """Set up the LG webOS Smart TV platform.""" if discovery_info is None: return host = discovery_info[CONF_HOST] name = discovery_info[CONF_NAME] customize = discovery_info[CONF_CUSTOMIZE] turn_on_action = discovery_info.get(CONF_ON_ACTION) client = opp.data[DOMAIN][host]["client"] on_script = Script(opp, turn_on_action, name, DOMAIN) if turn_on_action else None entity = LgWebOSMediaPlayerEntity(client, name, customize, on_script) async_add_entities([entity], update_before_add=False)
async def async_setup_entry(opp, config_entry): """Set up Panasonic Viera from a config entry.""" panasonic_viera_data = opp.data.setdefault(DOMAIN, {}) config = config_entry.data host = config[CONF_HOST] port = config[CONF_PORT] on_action = config[CONF_ON_ACTION] if on_action is not None: on_action = Script(opp, on_action, config[CONF_NAME], DOMAIN) params = {} if CONF_APP_ID in config and CONF_ENCRYPTION_KEY in config: params["app_id"] = config[CONF_APP_ID] params["encryption_key"] = config[CONF_ENCRYPTION_KEY] remote = Remote(opp, host, port, on_action, **params) await remote.async_create_remote_control(during_setup=True) panasonic_viera_data[config_entry.entry_id] = {ATTR_REMOTE: remote} # Add device_info to older config entries if ATTR_DEVICE_INFO not in config or config[ATTR_DEVICE_INFO] is None: device_info = await remote.async_get_device_info() unique_id = config_entry.unique_id if device_info is None: _LOGGER.error( "Couldn't gather device info; Please restart Open Peer Power with your TV turned on and connected to your network" ) else: unique_id = device_info[ATTR_UDN] opp.config_entries.async_update_entry( config_entry, unique_id=unique_id, data={ **config, ATTR_DEVICE_INFO: device_info }, ) opp.config_entries.async_setup_platforms(config_entry, PLATFORMS) return True
class WolSwitch(SwitchEntity): """Representation of a wake on lan switch.""" def __init__( self, opp, name, host, mac_address, off_action, broadcast_address, broadcast_port, ): """Initialize the WOL switch.""" self._opp = opp self._name = name self._host = host self._mac_address = mac_address self._broadcast_address = broadcast_address self._broadcast_port = broadcast_port domain = __name__.split(".")[-2] self._off_script = Script(opp, off_action, name, domain) if off_action else None self._state = False self._assumed_state = host is None self._unique_id = dr.format_mac(mac_address) @property def is_on(self): """Return true if switch is on.""" return self._state @property def name(self): """Return the name of the switch.""" return self._name @property def assumed_state(self): """Return true if no host is provided.""" return self._assumed_state @property def should_poll(self): """Return false if assumed state is true.""" return not self._assumed_state @property def unique_id(self): """Return the unique id of this switch.""" return self._unique_id def turn_on(self, **kwargs): """Turn the device on.""" service_kwargs = {} if self._broadcast_address is not None: service_kwargs["ip_address"] = self._broadcast_address if self._broadcast_port is not None: service_kwargs["port"] = self._broadcast_port _LOGGER.info( "Send magic packet to mac %s (broadcast: %s, port: %s)", self._mac_address, self._broadcast_address, self._broadcast_port, ) wakeonlan.send_magic_packet(self._mac_address, **service_kwargs) if self._assumed_state: self._state = True self.async_write_op_state() def turn_off(self, **kwargs): """Turn the device off if an off action is present.""" if self._off_script is not None: self._off_script.run(context=self._context) if self._assumed_state: self._state = False self.async_write_op_state() def update(self): """Check if device is on and update the state. Only called if assumed state is false.""" if platform.system().lower() == "windows": ping_cmd = [ "ping", "-n", "1", "-w", str(DEFAULT_PING_TIMEOUT * 1000), str(self._host), ] else: ping_cmd = [ "ping", "-c", "1", "-W", str(DEFAULT_PING_TIMEOUT), str(self._host), ] status = sp.call(ping_cmd, stdout=sp.DEVNULL, stderr=sp.DEVNULL) self._state = not bool(status)
def __init__( self, opp, device_id, friendly_name, state_template, icon_template, entity_picture_template, availability_template, on_action, off_action, level_action, level_template, temperature_action, temperature_template, color_action, color_template, white_value_action, white_value_template, effect_action, effect_list_template, effect_template, max_mireds_template, min_mireds_template, supports_transition_template, unique_id, ): """Initialize the light.""" super().__init__( availability_template=availability_template, icon_template=icon_template, entity_picture_template=entity_picture_template, ) self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id, opp=opp) self._name = friendly_name self._template = state_template domain = __name__.split(".")[-2] self._on_script = Script(opp, on_action, friendly_name, domain) self._off_script = Script(opp, off_action, friendly_name, domain) self._level_script = None if level_action is not None: self._level_script = Script(opp, level_action, friendly_name, domain) self._level_template = level_template self._temperature_script = None if temperature_action is not None: self._temperature_script = Script( opp, temperature_action, friendly_name, domain ) self._temperature_template = temperature_template self._color_script = None if color_action is not None: self._color_script = Script(opp, color_action, friendly_name, domain) self._color_template = color_template self._white_value_script = None if white_value_action is not None: self._white_value_script = Script( opp, white_value_action, friendly_name, domain ) self._white_value_template = white_value_template self._effect_script = None if effect_action is not None: self._effect_script = Script(opp, effect_action, friendly_name, domain) self._effect_list_template = effect_list_template self._effect_template = effect_template self._max_mireds_template = max_mireds_template self._min_mireds_template = min_mireds_template self._supports_transition_template = supports_transition_template self._state = False self._brightness = None self._temperature = None self._color = None self._white_value = None self._effect = None self._effect_list = None self._max_mireds = None self._min_mireds = None self._supports_transition = False self._unique_id = unique_id
def __init__(self, opp, object_id, name, icon, sequence): """Initialize the script.""" self.object_id = object_id self.icon = icon self.entity_id = ENTITY_ID_FORMAT.format(object_id) self.script = Script(opp, sequence, name, self.async_update_op_state)
class ScriptEntity(ToggleEntity): """Representation of a script entity.""" icon = None def __init__(self, opp, object_id, name, icon, sequence): """Initialize the script.""" self.object_id = object_id self.icon = icon self.entity_id = ENTITY_ID_FORMAT.format(object_id) self.script = Script(opp, sequence, name, self.async_update_op_state) @property def should_poll(self): """No polling needed.""" return False @property def name(self): """Return the name of the entity.""" return self.script.name @property def state_attributes(self): """Return the state attributes.""" attrs = {} attrs[ATTR_LAST_TRIGGERED] = self.script.last_triggered if self.script.can_cancel: attrs[ATTR_CAN_CANCEL] = self.script.can_cancel if self.script.last_action: attrs[ATTR_LAST_ACTION] = self.script.last_action return attrs @property def is_on(self): """Return true if script is on.""" return self.script.is_running async def async_turn_on(self, **kwargs): """Turn the script on.""" context = kwargs.get("context") self.async_set_context(context) self.opp.bus.async_fire( EVENT_SCRIPT_STARTED, { ATTR_NAME: self.script.name, ATTR_ENTITY_ID: self.entity_id }, context=context, ) try: await self.script.async_run(kwargs.get(ATTR_VARIABLES), context) except Exception as err: self.script.async_log_exception( _LOGGER, f"Error executing script {self.entity_id}", err) raise err async def async_turn_off(self, **kwargs): """Turn script off.""" self.script.async_stop() async def async_will_remove_from_opp(self): """Stop script and remove service when it will be removed from Open Peer Power.""" if self.script.is_running: self.script.async_stop() # remove service self.opp.services.async_remove(DOMAIN, self.object_id)
async def _async_process_config( opp: OpenPeerPower, config: dict[str, Any], component: EntityComponent, ) -> bool: """Process config and add automations. Returns if blueprints were used. """ entities = [] blueprints_used = False for config_key in extract_domain_configs(config, DOMAIN): conf: list[dict[str, Any] | blueprint.BlueprintInputs] = config[config_key] for list_no, config_block in enumerate(conf): raw_blueprint_inputs = None raw_config = None if isinstance(config_block, blueprint.BlueprintInputs): blueprints_used = True blueprint_inputs = config_block raw_blueprint_inputs = blueprint_inputs.config_with_inputs try: raw_config = blueprint_inputs.async_substitute() config_block = cast( Dict[str, Any], await async_validate_config_item(opp, raw_config), ) except vol.Invalid as err: LOGGER.error( "Blueprint %s generated invalid automation with inputs %s: %s", blueprint_inputs.blueprint.name, blueprint_inputs.inputs, humanize_error(config_block, err), ) continue else: raw_config = cast(AutomationConfig, config_block).raw_config automation_id = config_block.get(CONF_ID) name = config_block.get(CONF_ALIAS) or f"{config_key} {list_no}" initial_state = config_block.get(CONF_INITIAL_STATE) action_script = Script( opp, config_block[CONF_ACTION], name, DOMAIN, running_description="automation actions", script_mode=config_block[CONF_MODE], max_runs=config_block[CONF_MAX], max_exceeded=config_block[CONF_MAX_EXCEEDED], logger=LOGGER, # We don't pass variables here # Automation will already render them to use them in the condition # and so will pass them on to the script. ) if CONF_CONDITION in config_block: cond_func = await _async_process_if(opp, name, config, config_block) if cond_func is None: continue else: cond_func = None # Add trigger variables to variables variables = None if CONF_TRIGGER_VARIABLES in config_block: variables = ScriptVariables( dict(config_block[CONF_TRIGGER_VARIABLES].as_dict()) ) if CONF_VARIABLES in config_block: if variables: variables.variables.update(config_block[CONF_VARIABLES].as_dict()) else: variables = config_block[CONF_VARIABLES] entity = AutomationEntity( automation_id, name, config_block[CONF_TRIGGER], cond_func, action_script, initial_state, variables, config_block.get(CONF_TRIGGER_VARIABLES), raw_config, raw_blueprint_inputs, config_block[CONF_TRACE], ) entities.append(entity) if entities: await component.async_add_entities(entities) return blueprints_used
def __init__( self, opp, device_id, friendly_name, device_class, state_template, position_template, tilt_template, icon_template, entity_picture_template, availability_template, open_action, close_action, stop_action, position_action, tilt_action, optimistic, tilt_optimistic, unique_id, ): """Initialize the Template cover.""" super().__init__( availability_template=availability_template, icon_template=icon_template, entity_picture_template=entity_picture_template, ) self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id, opp=opp) self._name = friendly_name self._template = state_template self._position_template = position_template self._tilt_template = tilt_template self._device_class = device_class self._open_script = None domain = __name__.split(".")[-2] if open_action is not None: self._open_script = Script(opp, open_action, friendly_name, domain) self._close_script = None if close_action is not None: self._close_script = Script(opp, close_action, friendly_name, domain) self._stop_script = None if stop_action is not None: self._stop_script = Script(opp, stop_action, friendly_name, domain) self._position_script = None if position_action is not None: self._position_script = Script(opp, position_action, friendly_name, domain) self._tilt_script = None if tilt_action is not None: self._tilt_script = Script(opp, tilt_action, friendly_name, domain) self._optimistic = optimistic or (not state_template and not position_template) self._tilt_optimistic = tilt_optimistic or not tilt_template self._position = None self._is_opening = False self._is_closing = False self._tilt_value = None self._unique_id = unique_id
def __init__( self, opp, device_id, friendly_name, state_template, battery_level_template, fan_speed_template, availability_template, start_action, pause_action, stop_action, return_to_base_action, clean_spot_action, locate_action, set_fan_speed_action, fan_speed_list, attribute_templates, unique_id, ): """Initialize the vacuum.""" super().__init__( attribute_templates=attribute_templates, availability_template=availability_template, ) self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id, opp=opp) self._name = friendly_name self._template = state_template self._battery_level_template = battery_level_template self._fan_speed_template = fan_speed_template self._supported_features = SUPPORT_START domain = __name__.split(".")[-2] self._start_script = Script(opp, start_action, friendly_name, domain) self._pause_script = None if pause_action: self._pause_script = Script(opp, pause_action, friendly_name, domain) self._supported_features |= SUPPORT_PAUSE self._stop_script = None if stop_action: self._stop_script = Script(opp, stop_action, friendly_name, domain) self._supported_features |= SUPPORT_STOP self._return_to_base_script = None if return_to_base_action: self._return_to_base_script = Script( opp, return_to_base_action, friendly_name, domain ) self._supported_features |= SUPPORT_RETURN_HOME self._clean_spot_script = None if clean_spot_action: self._clean_spot_script = Script( opp, clean_spot_action, friendly_name, domain ) self._supported_features |= SUPPORT_CLEAN_SPOT self._locate_script = None if locate_action: self._locate_script = Script(opp, locate_action, friendly_name, domain) self._supported_features |= SUPPORT_LOCATE self._set_fan_speed_script = None if set_fan_speed_action: self._set_fan_speed_script = Script( opp, set_fan_speed_action, friendly_name, domain ) self._supported_features |= SUPPORT_FAN_SPEED self._state = None self._battery_level = None self._fan_speed = None if self._template: self._supported_features |= SUPPORT_STATE if self._battery_level_template: self._supported_features |= SUPPORT_BATTERY self._unique_id = unique_id # List of valid fan speeds self._fan_speed_list = fan_speed_list
def __init__( self, opp, device_id, friendly_name, state_template, speed_template, percentage_template, preset_mode_template, oscillating_template, direction_template, availability_template, on_action, off_action, set_speed_action, set_percentage_action, set_preset_mode_action, set_oscillating_action, set_direction_action, speed_count, speed_list, preset_modes, unique_id, ): """Initialize the fan.""" super().__init__(availability_template=availability_template) self.opp = opp self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id, opp=opp) self._name = friendly_name self._template = state_template self._speed_template = speed_template self._percentage_template = percentage_template self._preset_mode_template = preset_mode_template self._oscillating_template = oscillating_template self._direction_template = direction_template self._supported_features = 0 domain = __name__.split(".")[-2] self._on_script = Script(opp, on_action, friendly_name, domain) self._off_script = Script(opp, off_action, friendly_name, domain) self._set_speed_script = None if set_speed_action: self._set_speed_script = Script(opp, set_speed_action, friendly_name, domain) self._set_percentage_script = None if set_percentage_action: self._set_percentage_script = Script(opp, set_percentage_action, friendly_name, domain) self._set_preset_mode_script = None if set_preset_mode_action: self._set_preset_mode_script = Script(opp, set_preset_mode_action, friendly_name, domain) self._set_oscillating_script = None if set_oscillating_action: self._set_oscillating_script = Script(opp, set_oscillating_action, friendly_name, domain) self._set_direction_script = None if set_direction_action: self._set_direction_script = Script(opp, set_direction_action, friendly_name, domain) self._state = STATE_OFF self._speed = None self._percentage = None self._preset_mode = None self._oscillating = None self._direction = None if (self._speed_template or self._percentage_template or self._preset_mode_template): self._supported_features |= SUPPORT_SET_SPEED if self._oscillating_template: self._supported_features |= SUPPORT_OSCILLATE if self._direction_template: self._supported_features |= SUPPORT_DIRECTION self._unique_id = unique_id # Number of valid speeds self._speed_count = speed_count # List of valid speeds self._speed_list = speed_list # List of valid preset modes self._preset_modes = preset_modes