def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Uptime Robot binary_sensors."""
from pyuptimerobot import UptimeRobot
up_robot = UptimeRobot()
api_key = config.get(CONF_API_KEY)
monitors = up_robot.getMonitors(api_key)
devices = []
if not monitors or monitors.get("stat") != "ok":
_LOGGER.error("Error connecting to Uptime Robot")
return
for monitor in monitors["monitors"]:
devices.append(
UptimeRobotBinarySensor(
api_key,
up_robot,
monitor["id"],
monitor["friendly_name"],
monitor["url"],
)
)
add_entities(devices, True)
async def _validate_input(
self,
data: dict[str,
Any]) -> tuple[dict[str, str], UptimeRobotAccount | None]:
"""Validate the user input allows us to connect."""
errors: dict[str, str] = {}
response: UptimeRobotApiResponse | UptimeRobotApiError | None = None
key: str = data[CONF_API_KEY]
if key.startswith("ur") or key.startswith("m"):
LOGGER.error("Wrong API key type detected, use the 'main' API key")
errors["base"] = "not_main_key"
return errors, None
uptime_robot_api = UptimeRobot(key, async_get_clientsession(self.hass))
try:
response = await uptime_robot_api.async_get_account_details()
except UptimeRobotAuthenticationException as exception:
LOGGER.error(exception)
errors["base"] = "invalid_api_key"
except UptimeRobotException as exception:
LOGGER.error(exception)
errors["base"] = "cannot_connect"
except Exception as exception: # pylint: disable=broad-except
LOGGER.exception(exception)
errors["base"] = "unknown"
else:
if response.status != API_ATTR_OK:
errors["base"] = "unknown"
LOGGER.error(response.error.message)
account: UptimeRobotAccount | None = (
response.data
if response and response.data and response.data.email else None)
return errors, account
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Uptime Robot binary_sensors."""
from pyuptimerobot import UptimeRobot
up_robot = UptimeRobot()
api_key = config.get(CONF_API_KEY)
monitors = up_robot.getMonitors(api_key)
devices = []
if not monitors or monitors.get('stat') != 'ok':
_LOGGER.error("Error connecting to Uptime Robot")
return
for monitor in monitors['monitors']:
devices.append(
UptimeRobotBinarySensor(api_key, up_robot, monitor['id'],
monitor['friendly_name'], monitor['url']))
add_devices(devices, True)
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Uptime Robot binary_sensors."""
from pyuptimerobot import UptimeRobot
up_robot = UptimeRobot()
api_key = config.get(CONF_API_KEY)
monitors = up_robot.getMonitors(api_key)
devices = []
if not monitors or monitors.get('stat') != 'ok':
_LOGGER.error("Error connecting to Uptime Robot")
return
for monitor in monitors['monitors']:
devices.append(UptimeRobotBinarySensor(
api_key, up_robot, monitor['id'], monitor['friendly_name'],
monitor['url']))
add_entities(devices, True)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the Uptime Robot sensors."""
from pyuptimerobot import UptimeRobot
up_robot = UptimeRobot()
apikey = config.get(CONF_API_KEY)
monitors = up_robot.getMonitors(apikey)
devices = []
if not monitors or monitors.get('stat') != 'ok':
error = monitors.get('error', {})
_LOGGER.error(error.get('message', 'Something terrible happend :('))
return False
for monitor in monitors['monitors']:
devices.append(UptimeRobotSensor(
apikey, up_robot, monitorid=monitor['id'],
name=monitor['friendly_name'], target=monitor['url']))
add_devices(devices, True)
return True
async def async_setup_platform(hass: HomeAssistant,
config,
async_add_entities,
discovery_info=None):
"""Set up the Uptime Robot binary_sensors."""
uptime_robot_api = UptimeRobot()
api_key = config[CONF_API_KEY]
def api_wrapper():
return uptime_robot_api.getMonitors(api_key)
async def async_update_data():
"""Fetch data from API UptimeRobot API."""
async with async_timeout.timeout(10):
monitors = await hass.async_add_executor_job(api_wrapper)
if not monitors or monitors.get("stat") != "ok":
raise UpdateFailed("Error communicating with Uptime Robot API")
return monitors
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name="uptimerobot",
update_method=async_update_data,
update_interval=timedelta(seconds=60),
)
await coordinator.async_refresh()
if not coordinator.data or coordinator.data.get("stat") != "ok":
_LOGGER.error("Error connecting to Uptime Robot")
raise PlatformNotReady()
async_add_entities([
UptimeRobotBinarySensor(
coordinator,
BinarySensorEntityDescription(
key=monitor["id"],
name=monitor["friendly_name"],
device_class=DEVICE_CLASS_CONNECTIVITY,
),
target=monitor["url"],
) for monitor in coordinator.data["monitors"]
], )
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up Uptime Robot from a config entry."""
hass.data.setdefault(DOMAIN, {})
uptime_robot_api = UptimeRobot(
entry.data[CONF_API_KEY], async_get_clientsession(hass)
)
dev_reg = await async_get_registry(hass)
hass.data[DOMAIN][entry.entry_id] = coordinator = UptimeRobotDataUpdateCoordinator(
hass,
config_entry_id=entry.entry_id,
dev_reg=dev_reg,
api=uptime_robot_api,
)
await coordinator.async_config_entry_first_refresh()
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Set up UptimeRobot from a config entry."""
hass.data.setdefault(DOMAIN, {})
key: str = entry.data[CONF_API_KEY]
if key.startswith("ur") or key.startswith("m"):
raise ConfigEntryAuthFailed(
"Wrong API key type detected, use the 'main' API key")
uptime_robot_api = UptimeRobot(key, async_get_clientsession(hass))
dev_reg = dr.async_get(hass)
hass.data[DOMAIN][
entry.entry_id] = coordinator = UptimeRobotDataUpdateCoordinator(
hass,
config_entry_id=entry.entry_id,
dev_reg=dev_reg,
api=uptime_robot_api,
)
await coordinator.async_config_entry_first_refresh()
hass.config_entries.async_setup_platforms(entry, PLATFORMS)
return True
