def plex_configuration_callback(data):
"""Handle configuration changes."""
setup_plexserver(
host, data.get('token'),
cv.boolean(data.get('has_ssl')),
cv.boolean(data.get('do_not_verify')),
hass, config, add_entities_callback
)
def plex_configuration_callback(data):
"""Handle configuration changes."""
setup_plexserver(
host, data.get('token'),
cv.boolean(data.get('has_ssl')),
cv.boolean(data.get('do_not_verify')),
hass, config, add_devices_callback
)
def message_received(topic, payload, qos):
"""Handle new MQTT message."""
if topic == self._battery_level_topic and \
self._battery_level_template:
battery_level = self._battery_level_template\
.async_render_with_possible_json_value(
payload, error_value=None)
if battery_level is not None:
self._battery_level = int(battery_level)
if topic == self._charging_topic and self._charging_template:
charging = self._charging_template\
.async_render_with_possible_json_value(
payload, error_value=None)
if charging is not None:
self._charging = cv.boolean(charging)
if topic == self._cleaning_topic and self._cleaning_template:
cleaning = self._cleaning_template \
.async_render_with_possible_json_value(
payload, error_value=None)
if cleaning is not None:
self._cleaning = cv.boolean(cleaning)
if topic == self._docked_topic and self._docked_template:
docked = self._docked_template \
.async_render_with_possible_json_value(
payload, error_value=None)
if docked is not None:
self._docked = cv.boolean(docked)
if topic == self._error_topic and self._error_template:
error = self._error_template \
.async_render_with_possible_json_value(
payload, error_value=None)
if error is not None:
self._error = cv.string(error)
if self._docked:
if self._charging:
self._status = "Docked & Charging"
else:
self._status = "Docked"
elif self._cleaning:
self._status = "Cleaning"
elif self._error is not None and not self._error:
self._status = "Error: {}".format(self._error)
else:
self._status = "Stopped"
if topic == self._fan_speed_topic and self._fan_speed_template:
fan_speed = self._fan_speed_template\
.async_render_with_possible_json_value(
payload, error_value=None)
if fan_speed is not None:
self._fan_speed = fan_speed
self.async_schedule_update_ha_state()
def plex_configuration_callback(data):
"""Handle configuration changes."""
config = {
"host_and_port": host_and_port,
CONF_TOKEN: data.get("token"),
CONF_SSL: cv.boolean(data.get("ssl")),
CONF_VERIFY_SSL: cv.boolean(data.get("verify_ssl")),
}
setup_plex(configurator_info=config)
def message_received(topic, payload, qos):
"""Handle new MQTT message."""
if topic == self._battery_level_topic and \
self._battery_level_template:
battery_level = self._battery_level_template\
.async_render_with_possible_json_value(
payload,
error_value=None)
if battery_level is not None:
self._battery_level = int(battery_level)
if topic == self._charging_topic and self._charging_template:
charging = self._charging_template\
.async_render_with_possible_json_value(
payload,
error_value=None)
if charging is not None:
self._charging = cv.boolean(charging)
if topic == self._cleaning_topic and self._cleaning_template:
cleaning = self._cleaning_template \
.async_render_with_possible_json_value(
payload,
error_value=None)
if cleaning is not None:
self._cleaning = cv.boolean(cleaning)
if topic == self._docked_topic and self._docked_template:
docked = self._docked_template \
.async_render_with_possible_json_value(
payload,
error_value=None)
if docked is not None:
self._docked = cv.boolean(docked)
if self._docked:
if self._charging:
self._status = "Docked & Charging"
else:
self._status = "Docked"
elif self._cleaning:
self._status = "Cleaning"
else:
self._status = "Stopped"
if topic == self._fan_speed_topic and self._fan_speed_template:
fan_speed = self._fan_speed_template\
.async_render_with_possible_json_value(
payload,
error_value=None)
if fan_speed is not None:
self._fan_speed = fan_speed
self.async_schedule_update_ha_state()
def send_message(self, message="", **kwargs):
"""Send a message to a Android TV device."""
_LOGGER.debug("Sending notification to: %s", self._target)
payload = dict(
filename=("icon.png", open(self._icon_file, "rb"), "application/octet-stream", {"Expires": "0"}),
type="0",
title=kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT),
msg=message,
duration="%i" % self._default_duration,
position="%i" % POSITIONS.get(self._default_position),
bkgcolor="%s" % COLORS.get(self._default_color),
transparency="%i" % TRANSPARENCIES.get(self._default_transparency),
offset="0",
app=ATTR_TITLE_DEFAULT,
force="true",
interrupt="%i" % self._default_interrupt,
)
data = kwargs.get(ATTR_DATA)
if data:
if ATTR_DURATION in data:
duration = data.get(ATTR_DURATION)
try:
payload[ATTR_DURATION] = "%i" % int(duration)
except ValueError:
_LOGGER.warning("Invalid duration-value: %s", str(duration))
if ATTR_POSITION in data:
position = data.get(ATTR_POSITION)
if position in POSITIONS:
payload[ATTR_POSITION] = "%i" % POSITIONS.get(position)
else:
_LOGGER.warning("Invalid position-value: %s", str(position))
if ATTR_TRANSPARENCY in data:
transparency = data.get(ATTR_TRANSPARENCY)
if transparency in TRANSPARENCIES:
payload[ATTR_TRANSPARENCY] = "%i" % TRANSPARENCIES.get(transparency)
else:
_LOGGER.warning("Invalid transparency-value: %s", str(transparency))
if ATTR_COLOR in data:
color = data.get(ATTR_COLOR)
if color in COLORS:
payload[ATTR_BKGCOLOR] = "%s" % COLORS.get(color)
else:
_LOGGER.warning("Invalid color-value: %s", str(color))
if ATTR_INTERRUPT in data:
interrupt = data.get(ATTR_INTERRUPT)
try:
payload[ATTR_INTERRUPT] = "%i" % cv.boolean(interrupt)
except vol.Invalid:
_LOGGER.warning("Invalid interrupt-value: %s", str(interrupt))
try:
_LOGGER.debug("Payload: %s", str(payload))
response = requests.post(self._target, files=payload, timeout=self._timeout)
if response.status_code != 200:
_LOGGER.error("Error sending message: %s", str(response))
except requests.exceptions.ConnectionError as err:
_LOGGER.error("Error communicating with %s: %s", self._target, str(err))
def hm_set(self, value):
"""Set variable on homematic controller."""
if isinstance(self._state, bool):
value = cv.boolean(value)
else:
value = float(value)
self._homematic.setSystemVariable(self._hub_name, self._name, value)
self._state = value
self.schedule_update_ha_state()
def hm_set(self, value):
"""Set variable on homematic controller."""
if isinstance(self._state, bool):
value = cv.boolean(value)
else:
value = float(value)
self._homematic.setSystemVariable(self._hub_name, self._name, value)
self._state = value
self.schedule_update_ha_state()
def hm_set(self, value):
"""Set variable on homematic controller."""
if HOMEMATIC is not None:
if isinstance(self._state, bool):
value = cv.boolean(value)
else:
value = float(value)
HOMEMATIC.setSystemVariable(self._name, value)
self._state = value
self.update_ha_state()
def hm_set(self, value):
"""Set variable on homematic controller."""
if HOMEMATIC is not None:
if isinstance(self._state, bool):
value = cv.boolean(value)
else:
value = float(value)
HOMEMATIC.setSystemVariable(self._name, value)
self._state = value
self.update_ha_state()
def result_as_boolean(template_result: Optional[str]) -> bool:
"""Convert the template result to a boolean.
True/not 0/'1'/'true'/'yes'/'on'/'enable' are considered truthy
False/0/None/'0'/'false'/'no'/'off'/'disable' are considered falsy
"""
try:
return cv.boolean(template_result)
except vol.Invalid:
return False
def hm_set_variable(self, name, value):
"""Set variable value on CCU/Homegear."""
if name not in self._variables:
_LOGGER.error("Variable %s not found on %s", name, self.name)
return
old_value = self._variables.get(name)
if isinstance(old_value, bool):
value = cv.boolean(value)
else:
value = float(value)
self._homematic.setSystemVariable(self.name, name, value)
self._variables.update({name: value})
self.schedule_update_ha_state()
def result_as_boolean(template_result: str | None) -> bool:
"""Convert the template result to a boolean.
True/not 0/'1'/'true'/'yes'/'on'/'enable' are considered truthy
False/0/None/'0'/'false'/'no'/'off'/'disable' are considered falsy
"""
try:
# Import here, not at top-level to avoid circular import
from homeassistant.helpers import ( # pylint: disable=import-outside-toplevel
config_validation as cv, )
return cv.boolean(template_result)
except vol.Invalid:
return False
def get_miot_props(self, device, mapping: dict = None):
if mapping is None:
mapping = device.mapping or {}
rls = []
if dic := self.get_miio_props(device):
for k, v in mapping.items():
u = MiotSpec.unique_prop(v, valid=True)
c = self.specs.get(u, {})
p = c.get('prop')
if not p:
continue
val = dic.get(p)
prop = self.miot_spec.specs.get(u)
if prop and isinstance(prop, MiotProperty):
mph = MiioPropertyHelper(prop)
fmt = c.get('format')
try:
if tpl := c.get('template', {}):
tpl = CUSTOM_TEMPLATES.get(tpl, tpl)
tpl = cv.template(tpl)
tpl.hass = self.hass
val = tpl.render({
'value':
val,
'props':
dic,
'dict':
c.get('dict', {}),
'min':
prop.range_min(),
'max':
prop.range_max(),
'step':
prop.range_step(),
'description':
prop.list_description(val)
if prop.value_list else None,
})
elif fmt and hasattr(mph, fmt):
val = getattr(mph, fmt)(val)
elif d := c.get('dict', {}):
val = d.get(val, c.get('default', val))
elif prop.format in ['bool']:
val = cv.boolean(val)
def message_received(msg):
"""Handle new MQTT message."""
if (msg.topic == self._state_topics[CONF_BATTERY_LEVEL_TOPIC]
and self._templates[CONF_BATTERY_LEVEL_TEMPLATE]):
battery_level = self._templates[
CONF_BATTERY_LEVEL_TEMPLATE].async_render_with_possible_json_value(
msg.payload, None)
if battery_level:
self._battery_level = int(battery_level)
if (msg.topic == self._state_topics[CONF_CHARGING_TOPIC]
and self._templates[CONF_CHARGING_TEMPLATE]):
charging = self._templates[
CONF_CHARGING_TEMPLATE].async_render_with_possible_json_value(
msg.payload, None)
if charging:
self._charging = cv.boolean(charging)
if (msg.topic == self._state_topics[CONF_CLEANING_TOPIC]
and self._templates[CONF_CLEANING_TEMPLATE]):
cleaning = self._templates[
CONF_CLEANING_TEMPLATE].async_render_with_possible_json_value(
msg.payload, None)
if cleaning:
self._cleaning = cv.boolean(cleaning)
if (msg.topic == self._state_topics[CONF_DOCKED_TOPIC]
and self._templates[CONF_DOCKED_TEMPLATE]):
docked = self._templates[
CONF_DOCKED_TEMPLATE].async_render_with_possible_json_value(
msg.payload, None)
if docked:
self._docked = cv.boolean(docked)
if (msg.topic == self._state_topics[CONF_ERROR_TOPIC]
and self._templates[CONF_ERROR_TEMPLATE]):
error = self._templates[
CONF_ERROR_TEMPLATE].async_render_with_possible_json_value(
msg.payload, None)
if error is not None:
self._error = cv.string(error)
if self._docked:
if self._charging:
self._status = "Docked & Charging"
else:
self._status = "Docked"
elif self._cleaning:
self._status = "Cleaning"
elif self._error:
self._status = f"Error: {self._error}"
else:
self._status = "Stopped"
if (msg.topic == self._state_topics[CONF_FAN_SPEED_TOPIC]
and self._templates[CONF_FAN_SPEED_TEMPLATE]):
fan_speed = self._templates[
CONF_FAN_SPEED_TEMPLATE].async_render_with_possible_json_value(
msg.payload, None)
if fan_speed:
self._fan_speed = fan_speed
self.async_write_ha_state()
def update(self):
super().update()
if self._available:
attrs = self._state_attrs
self._state = cv.boolean(attrs.get(self._attr) or False)
def message_received(topic, payload, qos):
"""Handle new MQTT message."""
if topic == self._state_topics[CONF_BATTERY_LEVEL_TOPIC] and \
self._templates[CONF_BATTERY_LEVEL_TEMPLATE]:
battery_level = self._templates[CONF_BATTERY_LEVEL_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if battery_level is not None:
self._battery_level = int(battery_level)
if topic == self._state_topics[CONF_CHARGING_TOPIC] and \
self._templates[CONF_CHARGING_TEMPLATE]:
charging = self._templates[CONF_CHARGING_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if charging is not None:
self._charging = cv.boolean(charging)
if topic == self._state_topics[CONF_CLEANING_TOPIC] and \
self._templates[CONF_CLEANING_TEMPLATE]:
cleaning = self._templates[CONF_CLEANING_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if cleaning is not None:
self._cleaning = cv.boolean(cleaning)
if topic == self._state_topics[CONF_DOCKED_TOPIC] and \
self._templates[CONF_DOCKED_TEMPLATE]:
docked = self._templates[CONF_DOCKED_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if docked is not None:
self._docked = cv.boolean(docked)
if topic == self._state_topics[CONF_ERROR_TOPIC] and \
self._templates[CONF_ERROR_TEMPLATE]:
error = self._templates[CONF_ERROR_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if error is not None:
self._error = cv.string(error)
if self._docked:
if self._charging:
self._status = "Docked & Charging"
else:
self._status = "Docked"
elif self._cleaning:
self._status = "Cleaning"
elif self._error is not None and not self._error:
self._status = "Error: {}".format(self._error)
else:
self._status = "Stopped"
if topic == self._state_topics[CONF_FAN_SPEED_TOPIC] and \
self._templates[CONF_FAN_SPEED_TEMPLATE]:
fan_speed = self._templates[CONF_FAN_SPEED_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if fan_speed is not None:
self._fan_speed = fan_speed
self.async_schedule_update_ha_state()
def none_as_true(data):
"""Return a none value as a truth."""
if data is None:
return True
else:
return cv.boolean(data)
def send_message(self, message: str, **kwargs: Any) -> None:
"""Send a message to a Android TV device."""
data: dict | None = kwargs.get(ATTR_DATA)
title = kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT)
duration = None
fontsize = None
position = None
transparency = None
bkgcolor = None
interrupt = False
icon = None
image_file = None
if data:
if ATTR_DURATION in data:
try:
duration = int(
data.get(ATTR_DURATION,
Notifications.DEFAULT_DURATION))
except ValueError:
_LOGGER.warning("Invalid duration-value: %s",
data.get(ATTR_DURATION))
if ATTR_FONTSIZE in data:
if data.get(ATTR_FONTSIZE) in Notifications.FONTSIZES:
fontsize = data.get(ATTR_FONTSIZE)
else:
_LOGGER.warning("Invalid fontsize-value: %s",
data.get(ATTR_FONTSIZE))
if ATTR_POSITION in data:
if data.get(ATTR_POSITION) in Notifications.POSITIONS:
position = data.get(ATTR_POSITION)
else:
_LOGGER.warning("Invalid position-value: %s",
data.get(ATTR_POSITION))
if ATTR_TRANSPARENCY in data:
if data.get(ATTR_TRANSPARENCY) in Notifications.TRANSPARENCIES:
transparency = data.get(ATTR_TRANSPARENCY)
else:
_LOGGER.warning(
"Invalid transparency-value: %s",
data.get(ATTR_TRANSPARENCY),
)
if ATTR_COLOR in data:
if data.get(ATTR_COLOR) in Notifications.BKG_COLORS:
bkgcolor = data.get(ATTR_COLOR)
else:
_LOGGER.warning("Invalid color-value: %s",
data.get(ATTR_COLOR))
if ATTR_INTERRUPT in data:
try:
interrupt = cv.boolean(data.get(ATTR_INTERRUPT))
except vol.Invalid:
_LOGGER.warning("Invalid interrupt-value: %s",
data.get(ATTR_INTERRUPT))
if imagedata := data.get(ATTR_IMAGE):
image_file = self.load_file(
url=imagedata.get(ATTR_IMAGE_URL),
local_path=imagedata.get(ATTR_IMAGE_PATH),
username=imagedata.get(ATTR_IMAGE_USERNAME),
password=imagedata.get(ATTR_IMAGE_PASSWORD),
auth=imagedata.get(ATTR_IMAGE_AUTH),
)
if icondata := data.get(ATTR_ICON):
icon = self.load_file(
url=icondata.get(ATTR_ICON_URL),
local_path=icondata.get(ATTR_ICON_PATH),
username=icondata.get(ATTR_ICON_USERNAME),
password=icondata.get(ATTR_ICON_PASSWORD),
auth=icondata.get(ATTR_ICON_AUTH),
)
def send_message(self, message="", **kwargs):
"""Send a message to a Android TV device."""
_LOGGER.debug("Sending notification to: %s", self._target)
payload = dict(filename=('icon.png', self._icon_file,
'application/octet-stream',
{'Expires': '0'}), type='0',
title=kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT),
msg=message, duration='%i' % self._default_duration,
fontsize='%i' % FONTSIZES.get(self._default_fontsize),
position='%i' % POSITIONS.get(self._default_position),
bkgcolor='%s' % COLORS.get(self._default_color),
transparency='%i' % TRANSPARENCIES.get(
self._default_transparency),
offset='0', app=ATTR_TITLE_DEFAULT, force='true',
interrupt='%i' % self._default_interrupt,)
data = kwargs.get(ATTR_DATA)
if data:
if ATTR_DURATION in data:
duration = data.get(ATTR_DURATION)
try:
payload[ATTR_DURATION] = '%i' % int(duration)
except ValueError:
_LOGGER.warning("Invalid duration-value: %s",
str(duration))
if ATTR_FONTSIZE in data:
fontsize = data.get(ATTR_FONTSIZE)
if fontsize in FONTSIZES:
payload[ATTR_FONTSIZE] = '%i' % FONTSIZES.get(fontsize)
else:
_LOGGER.warning("Invalid fontsize-value: %s",
str(fontsize))
if ATTR_POSITION in data:
position = data.get(ATTR_POSITION)
if position in POSITIONS:
payload[ATTR_POSITION] = '%i' % POSITIONS.get(position)
else:
_LOGGER.warning("Invalid position-value: %s",
str(position))
if ATTR_TRANSPARENCY in data:
transparency = data.get(ATTR_TRANSPARENCY)
if transparency in TRANSPARENCIES:
payload[ATTR_TRANSPARENCY] = '%i' % TRANSPARENCIES.get(
transparency)
else:
_LOGGER.warning("Invalid transparency-value: %s",
str(transparency))
if ATTR_COLOR in data:
color = data.get(ATTR_COLOR)
if color in COLORS:
payload[ATTR_BKGCOLOR] = '%s' % COLORS.get(color)
else:
_LOGGER.warning("Invalid color-value: %s", str(color))
if ATTR_INTERRUPT in data:
interrupt = data.get(ATTR_INTERRUPT)
try:
payload[ATTR_INTERRUPT] = '%i' % cv.boolean(interrupt)
except vol.Invalid:
_LOGGER.warning("Invalid interrupt-value: %s",
str(interrupt))
filedata = data.get(ATTR_FILE) if data else None
if filedata is not None:
# Load from file or URL
file_as_bytes = self.load_file(
url=filedata.get(ATTR_FILE_URL),
local_path=filedata.get(ATTR_FILE_PATH),
username=filedata.get(ATTR_FILE_USERNAME),
password=filedata.get(ATTR_FILE_PASSWORD),
auth=filedata.get(ATTR_FILE_AUTH))
if file_as_bytes:
payload[ATTR_IMAGE] = (
'image', file_as_bytes,
'application/octet-stream', {'Expires': '0'})
try:
_LOGGER.debug("Payload: %s", str(payload))
response = requests.post(
self._target, files=payload, timeout=self._timeout)
if response.status_code != 200:
_LOGGER.error("Error sending message: %s", str(response))
except requests.exceptions.ConnectionError as err:
_LOGGER.error("Error communicating with %s: %s",
self._target, str(err))
def send_message(self, message="", **kwargs):
"""Send a message to a Android TV device."""
_LOGGER.debug("Sending notification to: %s", self._target)
payload = {
"filename": (
"icon.png",
self._icon_file,
"application/octet-stream",
{"Expires": "0"},
),
"type": "0",
"title": kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT),
"msg": message,
"duration": "%i" % self._default_duration,
"fontsize": "%i" % FONTSIZES.get(self._default_fontsize),
"position": "%i" % POSITIONS.get(self._default_position),
"bkgcolor": "%s" % COLORS.get(self._default_color),
"transparency": "%i" % TRANSPARENCIES.get(self._default_transparency),
"offset": "0",
"app": ATTR_TITLE_DEFAULT,
"force": "true",
"interrupt": "%i" % self._default_interrupt,
}
data = kwargs.get(ATTR_DATA)
if data:
if ATTR_DURATION in data:
duration = data.get(ATTR_DURATION)
try:
payload[ATTR_DURATION] = "%i" % int(duration)
except ValueError:
_LOGGER.warning("Invalid duration-value: %s", str(duration))
if ATTR_FONTSIZE in data:
fontsize = data.get(ATTR_FONTSIZE)
if fontsize in FONTSIZES:
payload[ATTR_FONTSIZE] = "%i" % FONTSIZES.get(fontsize)
else:
_LOGGER.warning("Invalid fontsize-value: %s", str(fontsize))
if ATTR_POSITION in data:
position = data.get(ATTR_POSITION)
if position in POSITIONS:
payload[ATTR_POSITION] = "%i" % POSITIONS.get(position)
else:
_LOGGER.warning("Invalid position-value: %s", str(position))
if ATTR_TRANSPARENCY in data:
transparency = data.get(ATTR_TRANSPARENCY)
if transparency in TRANSPARENCIES:
payload[ATTR_TRANSPARENCY] = "%i" % TRANSPARENCIES.get(transparency)
else:
_LOGGER.warning("Invalid transparency-value: %s", str(transparency))
if ATTR_COLOR in data:
color = data.get(ATTR_COLOR)
if color in COLORS:
payload[ATTR_BKGCOLOR] = "%s" % COLORS.get(color)
else:
_LOGGER.warning("Invalid color-value: %s", str(color))
if ATTR_INTERRUPT in data:
interrupt = data.get(ATTR_INTERRUPT)
try:
payload[ATTR_INTERRUPT] = "%i" % cv.boolean(interrupt)
except vol.Invalid:
_LOGGER.warning("Invalid interrupt-value: %s", str(interrupt))
filedata = data.get(ATTR_FILE) if data else None
if filedata is not None:
# Load from file or URL
file_as_bytes = self.load_file(
url=filedata.get(ATTR_FILE_URL),
local_path=filedata.get(ATTR_FILE_PATH),
username=filedata.get(ATTR_FILE_USERNAME),
password=filedata.get(ATTR_FILE_PASSWORD),
auth=filedata.get(ATTR_FILE_AUTH),
)
if file_as_bytes:
payload[ATTR_IMAGE] = (
"image",
file_as_bytes,
"application/octet-stream",
{"Expires": "0"},
)
try:
_LOGGER.debug("Payload: %s", str(payload))
response = requests.post(self._target, files=payload, timeout=self._timeout)
if response.status_code != HTTP_OK:
_LOGGER.error("Error sending message: %s", str(response))
except requests.exceptions.ConnectionError as err:
_LOGGER.error("Error communicating with %s: %s", self._target, str(err))
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_NAME
from homeassistant.helpers.entity import Entity
_LOGGER = logging.getLogger(__name__)
DEPENDENCIES = ['zabbix']
_CONF_TRIGGERS = 'triggers'
_CONF_HOSTIDS = 'hostids'
_CONF_INDIVIDUAL = 'individual'
_ZABBIX_ID_LIST_SCHEMA = vol.Schema([int])
_ZABBIX_TRIGGER_SCHEMA = vol.Schema({
vol.Optional(_CONF_HOSTIDS, default=[]): _ZABBIX_ID_LIST_SCHEMA,
vol.Optional(_CONF_INDIVIDUAL, default=False): cv.boolean(True),
vol.Optional(CONF_NAME, default=None): cv.string,
})
# SCAN_INTERVAL = 30
#
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(_CONF_TRIGGERS): vol.Any(_ZABBIX_TRIGGER_SCHEMA, None)
})
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Zabbix sensor platform."""
sensors = []
zapi = hass.data[zabbix.DOMAIN]
def message_received(topic, payload, qos):
"""Handle new MQTT message."""
if topic == self._state_topics[CONF_BATTERY_LEVEL_TOPIC] and \
self._templates[CONF_BATTERY_LEVEL_TEMPLATE]:
battery_level = self._templates[CONF_BATTERY_LEVEL_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if battery_level is not None:
self._battery_level = int(battery_level)
if topic == self._state_topics[CONF_CHARGING_TOPIC] and \
self._templates[CONF_CHARGING_TEMPLATE]:
charging = self._templates[CONF_CHARGING_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if charging is not None:
self._charging = cv.boolean(charging)
if topic == self._state_topics[CONF_CLEANING_TOPIC] and \
self._templates[CONF_CLEANING_TEMPLATE]:
cleaning = self._templates[CONF_CLEANING_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if cleaning is not None:
self._cleaning = cv.boolean(cleaning)
if topic == self._state_topics[CONF_DOCKED_TOPIC] and \
self._templates[CONF_DOCKED_TEMPLATE]:
docked = self._templates[CONF_DOCKED_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if docked is not None:
self._docked = cv.boolean(docked)
if topic == self._state_topics[CONF_ERROR_TOPIC] and \
self._templates[CONF_ERROR_TEMPLATE]:
error = self._templates[CONF_ERROR_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if error is not None:
self._error = cv.string(error)
if self._docked:
if self._charging:
self._status = "Docked & Charging"
else:
self._status = "Docked"
elif self._cleaning:
self._status = "Cleaning"
elif self._error is not None and not self._error:
self._status = "Error: {}".format(self._error)
else:
self._status = "Stopped"
if topic == self._state_topics[CONF_FAN_SPEED_TOPIC] and \
self._templates[CONF_FAN_SPEED_TEMPLATE]:
fan_speed = self._templates[CONF_FAN_SPEED_TEMPLATE]\
.async_render_with_possible_json_value(
payload, error_value=None)
if fan_speed is not None:
self._fan_speed = fan_speed
self.async_schedule_update_ha_state()
def send_message(self, message="", **kwargs):
"""Send a message to a Android TV device."""
data = kwargs.get(ATTR_DATA)
title = kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT)
duration = None
fontsize = None
position = None
transparency = None
bkgcolor = None
interrupt = None
icon = None
image_file = None
if data:
if ATTR_DURATION in data:
try:
duration = int(data.get(ATTR_DURATION))
except ValueError:
_LOGGER.warning("Invalid duration-value: %s",
str(data.get(ATTR_DURATION)))
if ATTR_FONTSIZE in data:
if data.get(ATTR_FONTSIZE) in Notifications.FONTSIZES:
fontsize = data.get(ATTR_FONTSIZE)
else:
_LOGGER.warning("Invalid fontsize-value: %s",
str(data.get(ATTR_FONTSIZE)))
if ATTR_POSITION in data:
if data.get(ATTR_POSITION) in Notifications.POSITIONS:
position = data.get(ATTR_POSITION)
else:
_LOGGER.warning("Invalid position-value: %s",
str(data.get(ATTR_POSITION)))
if ATTR_TRANSPARENCY in data:
if data.get(ATTR_TRANSPARENCY) in Notifications.TRANSPARENCIES:
transparency = data.get(ATTR_TRANSPARENCY)
else:
_LOGGER.warning(
"Invalid transparency-value: %s",
str(data.get(ATTR_TRANSPARENCY)),
)
if ATTR_COLOR in data:
if data.get(ATTR_COLOR) in Notifications.BKG_COLORS:
bkgcolor = data.get(ATTR_COLOR)
else:
_LOGGER.warning("Invalid color-value: %s",
str(data.get(ATTR_COLOR)))
if ATTR_INTERRUPT in data:
try:
interrupt = cv.boolean(data.get(ATTR_INTERRUPT))
except vol.Invalid:
_LOGGER.warning("Invalid interrupt-value: %s",
str(data.get(ATTR_INTERRUPT)))
filedata = data.get(ATTR_FILE) if data else None
if filedata is not None:
if ATTR_ICON in filedata:
icon = self.load_file(
url=filedata.get(ATTR_ICON),
local_path=filedata.get(ATTR_FILE_PATH),
username=filedata.get(ATTR_FILE_USERNAME),
password=filedata.get(ATTR_FILE_PASSWORD),
auth=filedata.get(ATTR_FILE_AUTH),
)
image_file = self.load_file(
url=filedata.get(ATTR_FILE_URL),
local_path=filedata.get(ATTR_FILE_PATH),
username=filedata.get(ATTR_FILE_USERNAME),
password=filedata.get(ATTR_FILE_PASSWORD),
auth=filedata.get(ATTR_FILE_AUTH),
)
self.notify.send(
message,
title=title,
duration=duration,
fontsize=fontsize,
position=position,
bkgcolor=bkgcolor,
transparency=transparency,
interrupt=interrupt,
icon=icon,
image_file=image_file,
)
def send_message(self, message="", **kwargs):
"""Send a message to a Android TV device."""
_LOGGER.debug("Sending notification to: %s", self._target)
payload = dict(
filename=('icon.png', self._icon_file, 'application/octet-stream',
{
'Expires': '0'
}),
type='0',
title=kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT),
msg=message,
duration='%i' % self._default_duration,
fontsize='%i' % FONTSIZES.get(self._default_fontsize),
position='%i' % POSITIONS.get(self._default_position),
bkgcolor='%s' % COLORS.get(self._default_color),
transparency='%i' % TRANSPARENCIES.get(self._default_transparency),
offset='0',
app=ATTR_TITLE_DEFAULT,
force='true',
interrupt='%i' % self._default_interrupt,
)
data = kwargs.get(ATTR_DATA)
if data:
if ATTR_DURATION in data:
duration = data.get(ATTR_DURATION)
try:
payload[ATTR_DURATION] = '%i' % int(duration)
except ValueError:
_LOGGER.warning("Invalid duration-value: %s",
str(duration))
if ATTR_FONTSIZE in data:
fontsize = data.get(ATTR_FONTSIZE)
if fontsize in FONTSIZES:
payload[ATTR_FONTSIZE] = '%i' % FONTSIZES.get(fontsize)
else:
_LOGGER.warning("Invalid fontsize-value: %s",
str(fontsize))
if ATTR_POSITION in data:
position = data.get(ATTR_POSITION)
if position in POSITIONS:
payload[ATTR_POSITION] = '%i' % POSITIONS.get(position)
else:
_LOGGER.warning("Invalid position-value: %s",
str(position))
if ATTR_TRANSPARENCY in data:
transparency = data.get(ATTR_TRANSPARENCY)
if transparency in TRANSPARENCIES:
payload[ATTR_TRANSPARENCY] = '%i' % TRANSPARENCIES.get(
transparency)
else:
_LOGGER.warning("Invalid transparency-value: %s",
str(transparency))
if ATTR_COLOR in data:
color = data.get(ATTR_COLOR)
if color in COLORS:
payload[ATTR_BKGCOLOR] = '%s' % COLORS.get(color)
else:
_LOGGER.warning("Invalid color-value: %s", str(color))
if ATTR_INTERRUPT in data:
interrupt = data.get(ATTR_INTERRUPT)
try:
payload[ATTR_INTERRUPT] = '%i' % cv.boolean(interrupt)
except vol.Invalid:
_LOGGER.warning("Invalid interrupt-value: %s",
str(interrupt))
filedata = data.get(ATTR_FILE) if data else None
if filedata is not None:
# Load from file or URL
file_as_bytes = self.load_file(
url=filedata.get(ATTR_FILE_URL),
local_path=filedata.get(ATTR_FILE_PATH),
username=filedata.get(ATTR_FILE_USERNAME),
password=filedata.get(ATTR_FILE_PASSWORD),
auth=filedata.get(ATTR_FILE_AUTH))
if file_as_bytes:
payload[ATTR_IMAGE] = ('image', file_as_bytes,
'application/octet-stream', {
'Expires': '0'
})
try:
_LOGGER.debug("Payload: %s", str(payload))
response = requests.post(self._target,
files=payload,
timeout=self._timeout)
if response.status_code != 200:
_LOGGER.error("Error sending message: %s", str(response))
except requests.exceptions.ConnectionError as err:
_LOGGER.error("Error communicating with %s: %s", self._target,
str(err))
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
DEPENDENCIES = ['zabbix']
_CONF_TRIGGERS = "triggers"
_CONF_HOSTIDS = "hostids"
_CONF_INDIVIDUAL = "individual"
_CONF_NAME = "name"
_ZABBIX_ID_LIST_SCHEMA = vol.Schema([int])
_ZABBIX_TRIGGER_SCHEMA = vol.Schema({
vol.Optional(_CONF_HOSTIDS, default=[]): _ZABBIX_ID_LIST_SCHEMA,
vol.Optional(_CONF_INDIVIDUAL, default=False): cv.boolean(True),
vol.Optional(_CONF_NAME, default=None): cv.string,
})
# SCAN_INTERVAL = 30
#
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
vol.Required(_CONF_TRIGGERS): vol.Any(_ZABBIX_TRIGGER_SCHEMA, None)
})
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Zabbix sensor platform."""
sensors = []
zapi = hass.data[zabbix.DOMAIN]
def send_message(self, message="", **kwargs):
"""Send a message to a Android TV device."""
_LOGGER.debug("Sending notification to: %s", self._target)
payload = dict(
filename=('icon.png', open(self._icon_file,
'rb'), 'application/octet-stream', {
'Expires': '0'
}),
type='0',
title=kwargs.get(ATTR_TITLE, ATTR_TITLE_DEFAULT),
msg=message,
duration="%i" % self._default_duration,
position='%i' % POSITIONS.get(self._default_position),
bkgcolor='%s' % COLORS.get(self._default_color),
transparency='%i' % TRANSPARENCIES.get(self._default_transparency),
offset='0',
app=ATTR_TITLE_DEFAULT,
force='true',
interrupt='%i' % self._default_interrupt)
data = kwargs.get(ATTR_DATA)
if data:
if ATTR_DURATION in data:
duration = data.get(ATTR_DURATION)
try:
payload[ATTR_DURATION] = '%i' % int(duration)
except ValueError:
_LOGGER.warning("Invalid duration-value: %s",
str(duration))
if ATTR_POSITION in data:
position = data.get(ATTR_POSITION)
if position in POSITIONS:
payload[ATTR_POSITION] = '%i' % POSITIONS.get(position)
else:
_LOGGER.warning("Invalid position-value: %s",
str(position))
if ATTR_TRANSPARENCY in data:
transparency = data.get(ATTR_TRANSPARENCY)
if transparency in TRANSPARENCIES:
payload[ATTR_TRANSPARENCY] = '%i' % TRANSPARENCIES.get(
transparency)
else:
_LOGGER.warning("Invalid transparency-value: %s",
str(transparency))
if ATTR_COLOR in data:
color = data.get(ATTR_COLOR)
if color in COLORS:
payload[ATTR_BKGCOLOR] = '%s' % COLORS.get(color)
else:
_LOGGER.warning("Invalid color-value: %s", str(color))
if ATTR_INTERRUPT in data:
interrupt = data.get(ATTR_INTERRUPT)
try:
payload[ATTR_INTERRUPT] = '%i' % cv.boolean(interrupt)
except vol.Invalid:
_LOGGER.warning("Invalid interrupt-value: %s",
str(interrupt))
try:
_LOGGER.debug("Payload: %s", str(payload))
response = requests.post(self._target,
files=payload,
timeout=self._timeout)
if response.status_code != 200:
_LOGGER.error("Error sending message: %s", str(response))
except requests.exceptions.ConnectionError as err:
_LOGGER.error("Error communicating with %s: %s", self._target,
str(err))
from homeassistant.helpers.entity import Entity
_LOGGER = logging.getLogger(__name__)
DEPENDENCIES = ['zabbix']
_CONF_TRIGGERS = 'triggers'
_CONF_HOSTIDS = 'hostids'
_CONF_INDIVIDUAL = 'individual'
_ZABBIX_ID_LIST_SCHEMA = vol.Schema([int])
_ZABBIX_TRIGGER_SCHEMA = vol.Schema({
vol.Optional(_CONF_HOSTIDS, default=[]):
_ZABBIX_ID_LIST_SCHEMA,
vol.Optional(_CONF_INDIVIDUAL, default=False):
cv.boolean(True),
vol.Optional(CONF_NAME, default=None):
cv.string,
})
# SCAN_INTERVAL = 30
#
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(_CONF_TRIGGERS): vol.Any(_ZABBIX_TRIGGER_SCHEMA, None)})
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Zabbix sensor platform."""
sensors = []
zapi = hass.data[zabbix.DOMAIN]
