234 lines
7.5 KiB
Python
234 lines
7.5 KiB
Python
"""Support for user- and CDC-based flu info sensors from Flu Near You."""
|
|
from datetime import timedelta
|
|
import logging
|
|
|
|
from pyflunearyou import Client
|
|
from pyflunearyou.errors import FluNearYouError
|
|
import voluptuous as vol
|
|
|
|
from homeassistant.components.sensor import PLATFORM_SCHEMA
|
|
from homeassistant.const import (
|
|
ATTR_ATTRIBUTION,
|
|
ATTR_STATE,
|
|
CONF_LATITUDE,
|
|
CONF_LONGITUDE,
|
|
CONF_MONITORED_CONDITIONS,
|
|
)
|
|
from homeassistant.helpers import aiohttp_client
|
|
import homeassistant.helpers.config_validation as cv
|
|
from homeassistant.helpers.entity import Entity
|
|
from homeassistant.util import Throttle
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
ATTR_CITY = "city"
|
|
ATTR_REPORTED_DATE = "reported_date"
|
|
ATTR_REPORTED_LATITUDE = "reported_latitude"
|
|
ATTR_REPORTED_LONGITUDE = "reported_longitude"
|
|
ATTR_STATE_REPORTS_LAST_WEEK = "state_reports_last_week"
|
|
ATTR_STATE_REPORTS_THIS_WEEK = "state_reports_this_week"
|
|
ATTR_ZIP_CODE = "zip_code"
|
|
|
|
DEFAULT_ATTRIBUTION = "Data provided by Flu Near You"
|
|
|
|
MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=10)
|
|
SCAN_INTERVAL = timedelta(minutes=30)
|
|
|
|
CATEGORY_CDC_REPORT = "cdc_report"
|
|
CATEGORY_USER_REPORT = "user_report"
|
|
|
|
TYPE_CDC_LEVEL = "level"
|
|
TYPE_CDC_LEVEL2 = "level2"
|
|
TYPE_USER_CHICK = "chick"
|
|
TYPE_USER_DENGUE = "dengue"
|
|
TYPE_USER_FLU = "flu"
|
|
TYPE_USER_LEPTO = "lepto"
|
|
TYPE_USER_NO_SYMPTOMS = "none"
|
|
TYPE_USER_SYMPTOMS = "symptoms"
|
|
TYPE_USER_TOTAL = "total"
|
|
|
|
EXTENDED_TYPE_MAPPING = {
|
|
TYPE_USER_FLU: "ili",
|
|
TYPE_USER_NO_SYMPTOMS: "no_symptoms",
|
|
TYPE_USER_TOTAL: "total_surveys",
|
|
}
|
|
|
|
SENSORS = {
|
|
CATEGORY_CDC_REPORT: [
|
|
(TYPE_CDC_LEVEL, "CDC Level", "mdi:biohazard", None),
|
|
(TYPE_CDC_LEVEL2, "CDC Level 2", "mdi:biohazard", None),
|
|
],
|
|
CATEGORY_USER_REPORT: [
|
|
(TYPE_USER_CHICK, "Avian Flu Symptoms", "mdi:alert", "reports"),
|
|
(TYPE_USER_DENGUE, "Dengue Fever Symptoms", "mdi:alert", "reports"),
|
|
(TYPE_USER_FLU, "Flu Symptoms", "mdi:alert", "reports"),
|
|
(TYPE_USER_LEPTO, "Leptospirosis Symptoms", "mdi:alert", "reports"),
|
|
(TYPE_USER_NO_SYMPTOMS, "No Symptoms", "mdi:alert", "reports"),
|
|
(TYPE_USER_SYMPTOMS, "Flu-like Symptoms", "mdi:alert", "reports"),
|
|
(TYPE_USER_TOTAL, "Total Symptoms", "mdi:alert", "reports"),
|
|
],
|
|
}
|
|
|
|
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
|
|
{
|
|
vol.Optional(CONF_LATITUDE): cv.latitude,
|
|
vol.Optional(CONF_LONGITUDE): cv.longitude,
|
|
vol.Required(CONF_MONITORED_CONDITIONS, default=list(SENSORS)): vol.All(
|
|
cv.ensure_list, [vol.In(SENSORS)]
|
|
),
|
|
}
|
|
)
|
|
|
|
|
|
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
|
|
"""Configure the platform and add the sensors."""
|
|
websession = aiohttp_client.async_get_clientsession(hass)
|
|
|
|
latitude = config.get(CONF_LATITUDE, hass.config.latitude)
|
|
longitude = config.get(CONF_LONGITUDE, hass.config.longitude)
|
|
|
|
fny = FluNearYouData(
|
|
Client(websession), latitude, longitude, config[CONF_MONITORED_CONDITIONS]
|
|
)
|
|
await fny.async_update()
|
|
|
|
sensors = [
|
|
FluNearYouSensor(fny, kind, name, category, icon, unit)
|
|
for category in config[CONF_MONITORED_CONDITIONS]
|
|
for kind, name, icon, unit in SENSORS[category]
|
|
]
|
|
|
|
async_add_entities(sensors, True)
|
|
|
|
|
|
class FluNearYouSensor(Entity):
|
|
"""Define a base Flu Near You sensor."""
|
|
|
|
def __init__(self, fny, kind, name, category, icon, unit):
|
|
"""Initialize the sensor."""
|
|
self._attrs = {ATTR_ATTRIBUTION: DEFAULT_ATTRIBUTION}
|
|
self._category = category
|
|
self._icon = icon
|
|
self._kind = kind
|
|
self._name = name
|
|
self._state = None
|
|
self._unit = unit
|
|
self.fny = fny
|
|
|
|
@property
|
|
def available(self):
|
|
"""Return True if entity is available."""
|
|
return bool(self.fny.data[self._category])
|
|
|
|
@property
|
|
def device_state_attributes(self):
|
|
"""Return the device state attributes."""
|
|
return self._attrs
|
|
|
|
@property
|
|
def icon(self):
|
|
"""Return the icon."""
|
|
return self._icon
|
|
|
|
@property
|
|
def name(self):
|
|
"""Return the name."""
|
|
return self._name
|
|
|
|
@property
|
|
def state(self):
|
|
"""Return the state."""
|
|
return self._state
|
|
|
|
@property
|
|
def unique_id(self):
|
|
"""Return a unique, HASS-friendly identifier for this entity."""
|
|
return f"{self.fny.latitude},{self.fny.longitude}_{self._kind}"
|
|
|
|
@property
|
|
def unit_of_measurement(self):
|
|
"""Return the unit the value is expressed in."""
|
|
return self._unit
|
|
|
|
async def async_update(self):
|
|
"""Update the sensor."""
|
|
await self.fny.async_update()
|
|
|
|
cdc_data = self.fny.data.get(CATEGORY_CDC_REPORT)
|
|
user_data = self.fny.data.get(CATEGORY_USER_REPORT)
|
|
|
|
if self._category == CATEGORY_CDC_REPORT and cdc_data:
|
|
self._attrs.update(
|
|
{
|
|
ATTR_REPORTED_DATE: cdc_data["week_date"],
|
|
ATTR_STATE: cdc_data["name"],
|
|
}
|
|
)
|
|
self._state = cdc_data[self._kind]
|
|
elif self._category == CATEGORY_USER_REPORT and user_data:
|
|
self._attrs.update(
|
|
{
|
|
ATTR_CITY: user_data["local"]["city"].split("(")[0],
|
|
ATTR_REPORTED_LATITUDE: user_data["local"]["latitude"],
|
|
ATTR_REPORTED_LONGITUDE: user_data["local"]["longitude"],
|
|
ATTR_STATE: user_data["state"]["name"],
|
|
ATTR_ZIP_CODE: user_data["local"]["zip"],
|
|
}
|
|
)
|
|
|
|
if self._kind in user_data["state"]["data"]:
|
|
states_key = self._kind
|
|
elif self._kind in EXTENDED_TYPE_MAPPING:
|
|
states_key = EXTENDED_TYPE_MAPPING[self._kind]
|
|
|
|
self._attrs[ATTR_STATE_REPORTS_THIS_WEEK] = user_data["state"]["data"][
|
|
states_key
|
|
]
|
|
self._attrs[ATTR_STATE_REPORTS_LAST_WEEK] = user_data["state"][
|
|
"last_week_data"
|
|
][states_key]
|
|
|
|
if self._kind == TYPE_USER_TOTAL:
|
|
self._state = sum(
|
|
v
|
|
for k, v in user_data["local"].items()
|
|
if k
|
|
in (
|
|
TYPE_USER_CHICK,
|
|
TYPE_USER_DENGUE,
|
|
TYPE_USER_FLU,
|
|
TYPE_USER_LEPTO,
|
|
TYPE_USER_SYMPTOMS,
|
|
)
|
|
)
|
|
else:
|
|
self._state = user_data["local"][self._kind]
|
|
|
|
|
|
class FluNearYouData:
|
|
"""Define a data object to retrieve info from Flu Near You."""
|
|
|
|
def __init__(self, client, latitude, longitude, sensor_types):
|
|
"""Initialize."""
|
|
self._client = client
|
|
self._sensor_types = sensor_types
|
|
self.data = {}
|
|
self.latitude = latitude
|
|
self.longitude = longitude
|
|
|
|
@Throttle(MIN_TIME_BETWEEN_UPDATES)
|
|
async def async_update(self):
|
|
"""Update Flu Near You data."""
|
|
for key, method in [
|
|
(CATEGORY_CDC_REPORT, self._client.cdc_reports.status_by_coordinates),
|
|
(CATEGORY_USER_REPORT, self._client.user_reports.status_by_coordinates),
|
|
]:
|
|
if key in self._sensor_types:
|
|
try:
|
|
self.data[key] = await method(self.latitude, self.longitude)
|
|
except FluNearYouError as err:
|
|
_LOGGER.error('There was an error with "%s" data: %s', key, err)
|
|
self.data[key] = {}
|
|
|
|
_LOGGER.debug("New data stored: %s", self.data)
|