def __init__(
self,
hass,
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,
entity_ids,
):
"""Initialize the Template cover."""
self.hass = hass
self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT,
device_id,
hass=hass)
self._name = friendly_name
self._template = state_template
self._position_template = position_template
self._tilt_template = tilt_template
self._icon_template = icon_template
self._device_class = device_class
self._entity_picture_template = entity_picture_template
self._availability_template = availability_template
self._open_script = None
if open_action is not None:
self._open_script = Script(hass, open_action)
self._close_script = None
if close_action is not None:
self._close_script = Script(hass, close_action)
self._stop_script = None
if stop_action is not None:
self._stop_script = Script(hass, stop_action)
self._position_script = None
if position_action is not None:
self._position_script = Script(hass, position_action)
self._tilt_script = None
if tilt_action is not None:
self._tilt_script = Script(hass, tilt_action)
self._optimistic = optimistic or (not state_template
and not position_template)
self._tilt_optimistic = tilt_optimistic or not tilt_template
self._icon = None
self._entity_picture = None
self._position = None
self._tilt_value = None
self._entities = entity_ids
self._available = True
def __init__(self, hass, name, value_template, command_lock,
command_unlock, optimistic):
self._state = None
self._hass = hass
self._name = name
self._state_template = value_template
self._state_entities = value_template.extract_entities()
self._command_lock = Script(hass, command_lock)
self._command_unlock = Script(hass, command_unlock)
self._optimistic = optimistic
def __init__(self, hass, name, value_template, entity_ids,
command_lock, command_unlock, optimistic):
"""Initialize the lock."""
self._state = None
self._hass = hass
self._name = name
self._state_template = value_template
self._state_entities = entity_ids
self._command_lock = Script(hass, command_lock)
self._command_unlock = Script(hass, command_unlock)
self._optimistic = optimistic
def __init__(self, hass, device_id, friendly_name, state_template,
on_action, off_action, entity_ids):
"""Initialize the Template switch."""
self.hass = hass
self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id,
hass=hass)
self._name = friendly_name
self._template = state_template
self._on_script = Script(hass, on_action)
self._off_script = Script(hass, off_action)
self._state = False
self._entities = entity_ids
def __init__(
self,
hass,
device_id,
friendly_name,
state_template,
icon_template,
entity_picture_template,
availability_template,
on_action,
off_action,
level_action,
level_template,
entity_ids,
temperature_action,
temperature_template,
color_action,
color_template,
):
"""Initialize the light."""
self.hass = hass
self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT,
device_id,
hass=hass)
self._name = friendly_name
self._template = state_template
self._icon_template = icon_template
self._entity_picture_template = entity_picture_template
self._availability_template = availability_template
self._on_script = Script(hass, on_action)
self._off_script = Script(hass, off_action)
self._level_script = None
if level_action is not None:
self._level_script = Script(hass, level_action)
self._level_template = level_template
self._temperature_script = None
if temperature_action is not None:
self._temperature_script = Script(hass, temperature_action)
self._temperature_template = temperature_template
self._color_script = None
if color_action is not None:
self._color_script = Script(hass, color_action)
self._color_template = color_template
self._state = False
self._icon = None
self._entity_picture = None
self._brightness = None
self._temperature = None
self._color = None
self._entities = entity_ids
self._available = True
def __init__(self, hass, device_id, friendly_name, state_template,
speed_template, oscillating_template, direction_template,
on_action, off_action, set_speed_action,
set_oscillating_action, set_direction_action, speed_list,
entity_ids):
"""Initialize the fan."""
self.hass = hass
self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT,
device_id,
hass=hass)
self._name = friendly_name
self._template = state_template
self._speed_template = speed_template
self._oscillating_template = oscillating_template
self._direction_template = direction_template
self._supported_features = 0
self._on_script = Script(hass, on_action)
self._off_script = Script(hass, off_action)
self._set_speed_script = None
if set_speed_action:
self._set_speed_script = Script(hass, set_speed_action)
self._set_oscillating_script = None
if set_oscillating_action:
self._set_oscillating_script = Script(hass, set_oscillating_action)
self._set_direction_script = None
if set_direction_action:
self._set_direction_script = Script(hass, set_direction_action)
self._state = STATE_OFF
self._speed = None
self._oscillating = None
self._direction = None
self._template.hass = self.hass
if self._speed_template:
self._speed_template.hass = self.hass
self._supported_features |= SUPPORT_SET_SPEED
if self._oscillating_template:
self._oscillating_template.hass = self.hass
self._supported_features |= SUPPORT_OSCILLATE
if self._direction_template:
self._direction_template.hass = self.hass
self._supported_features |= SUPPORT_DIRECTION
self._entities = entity_ids
# List of valid speeds
self._speed_list = speed_list
def __init__(
self,
hass,
object_id,
name,
cast_is_on,
value,
is_volume_muted,
off_script,
on_script,
default_volume_template,
):
"""Initialize a Cast Volume Tracker."""
self.hass = hass
# strings
self.entity_id = ENTITY_ID_FORMAT.format(object_id)
self.object_id = object_id
self.media_player = f"{MEDIA_PLAYER_DOMAIN}.{object_id}"
self._entities = [f"{MEDIA_PLAYER_DOMAIN}.{object_id}"]
self._name = name
# state attributes - floats
self.value = value
self.value_prev = value
self.mp_volume_level = None
self.mp_volume_level_prev = None
# state attributes - booleans
self.cast_is_on = cast_is_on
self.cast_is_on_prev = cast_is_on
self.is_volume_muted = is_volume_muted
# flags
self.volume_management_enabled = True
# scripts
if off_script:
self._off_script = Script(hass, off_script)
else:
self._off_script = None
if on_script:
self._on_script = Script(hass, on_script)
else:
self._on_script = None
# template
self.default_volume_template = default_volume_template
if default_volume_template:
self.default_volume_template.hass = hass
def __init__(self, hass, device_id, friendly_name, state_template,
position_template, tilt_template, icon_template, open_action,
close_action, stop_action, position_action, tilt_action,
open_time, close_time, optimistic, tilt_optimistic,
entity_ids):
"""Initialize the Template cover."""
self.hass = hass
self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT,
device_id,
hass=hass)
self._name = friendly_name
self._template = state_template
self._position_template = position_template
self._tilt_template = tilt_template
self._icon_template = icon_template
self._open_script = None
if open_action is not None:
self._open_script = Script(hass, open_action)
self._close_script = None
if close_action is not None:
self._close_script = Script(hass, close_action)
self._stop_script = None
if stop_action is not None:
self._stop_script = Script(hass, stop_action)
self._position_script = None
if position_action is not None:
self._position_script = Script(hass, position_action)
self._tilt_script = None
if tilt_action is not None:
self._tilt_script = Script(hass, tilt_action)
self._open_time = open_time
self._close_time = close_time
self._optimistic = (optimistic
or (not state_template and not position_template))
self._tilt_optimistic = tilt_optimistic or not tilt_template
self._icon = None
self._position = 0
self._tilt_value = None #Disabled because my shades don't have tilt.
self._in_motion = False
self._entities = entity_ids
if self._template is not None:
self._template.hass = self.hass
if self._position_template is not None:
self._position_template.hass = self.hass
if self._tilt_template is not None:
self._tilt_template.hass = self.hass
if self._icon_template is not None:
self._icon_template.hass = self.hass
def __init__(
self,
hass,
config,
unique_id,
):
"""Initialize the lock."""
super().__init__(config=config)
self._state = None
self._name = name = config.get(CONF_NAME)
self._state_template = config.get(CONF_VALUE_TEMPLATE)
self._command_lock = Script(hass, config[CONF_LOCK], name, DOMAIN)
self._command_unlock = Script(hass, config[CONF_UNLOCK], name, DOMAIN)
self._optimistic = config.get(CONF_OPTIMISTIC)
self._unique_id = unique_id
def __init__(
self,
hass,
device_id,
friendly_name,
device_class,
state_template,
icon_template,
entity_picture_template,
availability_template,
open_action,
close_action,
stop_action,
travel_time_down,
travel_time_up,
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,
hass=hass)
self._name = friendly_name
self._template = state_template
self._device_class = device_class
self._open_script = None
domain = __name__.split(".")[-2]
if open_action is not None:
self._open_script = Script(hass, open_action, friendly_name,
domain)
self._close_script = None
if close_action is not None:
self._close_script = Script(hass, close_action, friendly_name,
domain)
self._stop_script = None
if stop_action is not None:
self._stop_script = Script(hass, stop_action, friendly_name,
domain)
self._state = None
self._unique_id = unique_id
self._opening_timer = None
self._closing_timer = None
self._travel_time_down = travel_time_down
self._travel_time_up = travel_time_up
def __init__(self, hass, 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(
hass,
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(hass, config_entry):
"""Set up Panasonic Viera from a config entry."""
panasonic_viera_data = hass.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(hass, on_action)
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(hass, host, port, on_action, **params)
await remote.async_create_remote_control(during_setup=True)
panasonic_viera_data[config_entry.entry_id] = {ATTR_REMOTE: remote}
for component in PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(
config_entry, component))
return True
def __init__(
self,
hass: HomeAssistant,
config,
unique_id: str | None,
) -> None:
"""Initialize the number."""
super().__init__(config=config)
self._attr_name = DEFAULT_NAME
self._name_template = name_template = config[CONF_NAME]
name_template.hass = hass
with contextlib.suppress(TemplateError):
self._attr_name = name_template.async_render(parse_result=False)
self._value_template = config[CONF_STATE]
self._command_set_value = Script(
hass, config[CONF_SET_VALUE], self._attr_name, DOMAIN
)
self._step_template = config[ATTR_STEP]
self._min_value_template = config[ATTR_MIN]
self._max_value_template = config[ATTR_MAX]
self._attr_assumed_state = self._optimistic = config[CONF_OPTIMISTIC]
self._attr_unique_id = unique_id
self._attr_value = None
self._attr_step = None
self._attr_min_value = None
self._attr_max_value = None
def _create_binary_sensor(hass: HomeAssistant, knx_module: XKNX,
config: ConfigType) -> XknxBinarySensor:
"""Return a KNX binary sensor to be used within XKNX."""
device_name = config[CONF_NAME]
actions = []
automations = config.get(BinarySensorSchema.CONF_AUTOMATION)
if automations is not None:
for automation in automations:
counter = automation[BinarySensorSchema.CONF_COUNTER]
hook = automation[BinarySensorSchema.CONF_HOOK]
action = automation[BinarySensorSchema.CONF_ACTION]
script_name = f"{device_name} turn ON script"
script = Script(hass, action, script_name, DOMAIN)
action = XknxActionCallback(knx_module,
script.async_run,
hook=hook,
counter=counter)
actions.append(action)
return XknxBinarySensor(
knx_module,
name=device_name,
group_address_state=config[BinarySensorSchema.CONF_STATE_ADDRESS],
sync_state=config[BinarySensorSchema.CONF_SYNC_STATE],
device_class=config.get(CONF_DEVICE_CLASS),
ignore_internal_state=config[
BinarySensorSchema.CONF_IGNORE_INTERNAL_STATE],
reset_after=config.get(BinarySensorSchema.CONF_RESET_AFTER),
actions=actions,
)
def __init__(
self,
hass: HomeAssistant,
name_template: Template | None,
value_template: Template,
availability_template: Template | None,
command_select_option: dict[str, Any],
options_template: Template,
optimistic: bool,
unique_id: str | None,
icon_template: Template | None,
) -> None:
"""Initialize the select."""
super().__init__(
availability_template=availability_template, icon_template=icon_template
)
self._attr_name = DEFAULT_NAME
name_template.hass = hass
with contextlib.suppress(TemplateError):
self._attr_name = name_template.async_render(parse_result=False)
self._name_template = name_template
self._value_template = value_template
domain = __name__.split(".")[-2]
self._command_select_option = Script(
hass, command_select_option, self._attr_name, domain
)
self._options_template = options_template
self._attr_assumed_state = self._optimistic = optimistic
self._attr_unique_id = unique_id
self._attr_options = None
self._attr_current_option = None
def __init__(
self,
hass: HomeAssistant,
name_template: Template,
value_template: Template,
availability_template: Template | None,
command_set_value: dict[str, Any],
step_template: Template,
minimum_template: Template | None,
maximum_template: Template | None,
optimistic: bool,
unique_id: str | None,
) -> None:
"""Initialize the number."""
super().__init__(availability_template=availability_template)
self._attr_name = DEFAULT_NAME
self._name_template = name_template
name_template.hass = hass
with contextlib.suppress(TemplateError):
self._attr_name = name_template.async_render(parse_result=False)
self._value_template = value_template
domain = __name__.split(".")[-2]
self._command_set_value = Script(hass, command_set_value,
self._attr_name, domain)
self._step_template = step_template
self._min_value_template = minimum_template
self._max_value_template = maximum_template
self._attr_assumed_state = self._optimistic = optimistic
self._attr_unique_id = unique_id
self._attr_value = None
self._attr_step = None
def create_automation_entity(device_id: str,
conf: dict = {}) -> CustomAutomation:
"""Create a CustomAutomation instance."""
base = get_base()
entity_id = f"{PLATFORM}.{device_id}"
alias: str = conf.get(CONF_ALIAS, entity_id.split(".")[-1])
entity = CustomAutomation(
conf.get(CONF_ID,
entity_id.split(".")[-1]),
alias,
conf.get(CONF_TRIGGER),
None, # Not supporting contitions at this time
Script(
base.hass,
conf.get(CONF_ACTION),
alias,
PLATFORM_AUTOMATION,
running_description="automation actions",
script_mode=conf.get(CONF_MODE, SCRIPT_MODE_RESTART),
max_runs=conf.get(CONF_MAX),
max_exceeded=conf.get(CONF_MAX_EXCEEDED),
logger=base.log,
),
conf.get(CONF_INITIAL_STATE),
conf.get(CONF_VARIABLES),
)
entity.entity_id = entity_id
entity.editable = False
return entity
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up the Samsung TV from a config entry."""
ip_address = config_entry.data[CONF_IP_ADDRESS]
on_script = None
if (
DOMAIN in hass.data
and ip_address in hass.data[DOMAIN]
and CONF_ON_ACTION in hass.data[DOMAIN][ip_address]
and hass.data[DOMAIN][ip_address][CONF_ON_ACTION]
):
turn_on_action = hass.data[DOMAIN][ip_address][CONF_ON_ACTION]
on_script = Script(hass, turn_on_action)
# Initialize bridge
data = config_entry.data.copy()
bridge = SamsungTVBridge.get_bridge(
data[CONF_METHOD], data[CONF_HOST], data[CONF_PORT], data.get(CONF_TOKEN),
)
if bridge.port is None and bridge.default_port is not None:
# For backward compat, set default port for websocket tv
data[CONF_PORT] = bridge.default_port
hass.config_entries.async_update_entry(config_entry, data=data)
bridge = SamsungTVBridge.get_bridge(
data[CONF_METHOD], data[CONF_HOST], data[CONF_PORT], data.get(CONF_TOKEN),
)
async_add_entities([SamsungTVDevice(bridge, config_entry, on_script)])
def __init__(self, hass, bot, command):
self.hass = hass
self.bot = bot
self.script = None
self.response = None
self.command = command[COMMAND]
_script = command.get(SCRIPT, None)
if _script is not None:
self.script = Script(hass, _script)
_response = command.get(RESPONSE, None)
if _response is not None:
self.response = {RESPONSE_TEXT: _response.get(RESPONSE_TEXT, None)}
_keyboard = _response.get(RESPONSE_KEYBOARD, None)
if _keyboard:
self.response[RESPONSE_KEYBOARD] = {
"keyboard": [],
"resize_keyboard": True,
"one_time_keyboard": True
}
for _key in _keyboard:
self.response[RESPONSE_KEYBOARD]["keyboard"].append([{
"text":
_key
}])
else:
self.response[RESPONSE_KEYBOARD] = None
async def select_source(self, source):
"""Set the input source."""
if source in self._input_templates:
source_script = Script(self.hass, self._input_templates[source])
if self._current_source_template is None:
self._current_source = source
self.async_write_ha_state()
await source_script.async_run(context=self._context)
def __init__(
self,
hass,
object_id,
config,
unique_id,
):
"""Initialize the Template switch."""
super().__init__(config=config)
self.entity_id = async_generate_entity_id(
ENTITY_ID_FORMAT, object_id, hass=hass
)
self._name = friendly_name = config.get(ATTR_FRIENDLY_NAME, object_id)
self._template = config.get(CONF_VALUE_TEMPLATE)
self._on_script = Script(hass, config[ON_ACTION], friendly_name, DOMAIN)
self._off_script = Script(hass, config[OFF_ACTION], friendly_name, DOMAIN)
self._state = False
self._unique_id = unique_id
def __init__(self, hass, name, host, mac_address, off_action, broadcast_address):
"""Initialize the WOL switch."""
self._hass = hass
self._name = name
self._host = host
self._mac_address = mac_address
self._broadcast_address = broadcast_address
self._off_script = Script(hass, off_action) if off_action else None
self._state = False
def __init__(
self,
hass,
device_id,
friendly_name,
state_template,
icon_template,
entity_picture_template,
on_action,
off_action,
level_action,
level_template,
entity_ids,
):
"""Initialize the light."""
self.hass = hass
self.entity_id = async_generate_entity_id(
ENTITY_ID_FORMAT, device_id, hass=hass
)
self._name = friendly_name
self._template = state_template
self._icon_template = icon_template
self._entity_picture_template = entity_picture_template
self._on_script = Script(hass, on_action)
self._off_script = Script(hass, off_action)
self._level_script = None
if level_action is not None:
self._level_script = Script(hass, level_action)
self._level_template = level_template
self._state = False
self._icon = None
self._entity_picture = None
self._brightness = None
self._entities = entity_ids
if self._template is not None:
self._template.hass = self.hass
if self._level_template is not None:
self._level_template.hass = self.hass
if self._icon_template is not None:
self._icon_template.hass = self.hass
if self._entity_picture_template is not None:
self._entity_picture_template.hass = self.hass
def __init__(self, hass, 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(hass,
sequence,
name,
self.async_write_ha_state,
logger=_LOGGER)
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up the Samsung TV from a config entry."""
ip_address = config_entry.data[CONF_IP_ADDRESS]
on_script = None
if (DOMAIN in hass.data and ip_address in hass.data[DOMAIN]
and CONF_ON_ACTION in hass.data[DOMAIN][ip_address]
and hass.data[DOMAIN][ip_address][CONF_ON_ACTION]):
turn_on_action = hass.data[DOMAIN][ip_address][CONF_ON_ACTION]
on_script = Script(hass, turn_on_action)
async_add_entities([SamsungTVDevice(config_entry, on_script)])
async def async_setup_entry(hass, entry, async_add_entities):
"""Set up the Samsung TV from a config entry."""
bridge = hass.data[DOMAIN][entry.entry_id]
host = entry.data[CONF_HOST]
on_script = None
data = hass.data[DOMAIN]
if turn_on_action := data.get(host, {}).get(CONF_ON_ACTION):
on_script = Script(hass, turn_on_action,
entry.data.get(CONF_NAME, DEFAULT_NAME), DOMAIN)
def __init__(self, hass, device_id, friendly_name, state_template,
on_action, off_action, entity_ids):
"""Initialize the Template switch."""
self.hass = hass
self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT, device_id,
hass=hass)
self._name = friendly_name
self._template = state_template
self._on_script = Script(hass, on_action)
self._off_script = Script(hass, off_action)
self._state = False
@callback
def template_switch_state_listener(entity, old_state, new_state):
"""Called when the target device changes state."""
hass.async_add_job(self.async_update_ha_state, True)
async_track_state_change(
hass, entity_ids, template_switch_state_listener)
def __init__(
self,
hass,
object_id,
config,
unique_id,
):
"""Initialize the Template switch."""
super().__init__(
hass, config=config, fallback_name=object_id, unique_id=unique_id
)
self.entity_id = async_generate_entity_id(
ENTITY_ID_FORMAT, object_id, hass=hass
)
friendly_name = self._attr_name
self._template = config.get(CONF_VALUE_TEMPLATE)
self._on_script = Script(hass, config[ON_ACTION], friendly_name, DOMAIN)
self._off_script = Script(hass, config[OFF_ACTION], friendly_name, DOMAIN)
self._state: bool | None = False
def __init__(self, hass, device_id, friendly_name, state_template,
position_template, tilt_template, icon_template, open_action,
close_action, stop_action, position_action, tilt_action,
entity_ids):
"""Initialize the Template cover."""
self.hass = hass
self.entity_id = async_generate_entity_id(ENTITY_ID_FORMAT,
device_id,
hass=hass)
self._name = friendly_name
self._template = state_template
self._position_template = position_template
self._tilt_template = tilt_template
self._icon_template = icon_template
self._open_script = None
if open_action is not None:
self._open_script = Script(hass, open_action)
self._close_script = None
if close_action is not None:
self._close_script = Script(hass, close_action)
self._stop_script = None
if stop_action is not None:
self._stop_script = Script(hass, stop_action)
self._position_script = None
if position_action is not None:
self._position_script = Script(hass, position_action)
self._tilt_script = None
if tilt_action is not None:
self._tilt_script = Script(hass, tilt_action)
self._icon = None
self._position = None
self._tilt_value = None
self._entities = entity_ids
if self._template is not None:
self._template.hass = self.hass
if self._position_template is not None:
self._position_template.hass = self.hass
if self._tilt_template is not None:
self._tilt_template.hass = self.hass
if self._icon_template is not None:
self._icon_template.hass = self.hass
def __init__(self, hass, device, hook, action, counter=1):
"""Initialize Automation class."""
self.hass = hass
self.device = device
script_name = "{} turn ON script".format(device.get_name())
self.script = Script(hass, action, script_name)
self.action = ActionCallback(
hass.data[DATA_KNX].xknx, self.script.async_run, hook=hook, counter=counter
)
device.actions.append(self.action)
