266 lines
8.9 KiB
Python
266 lines
8.9 KiB
Python
"""
|
|
Support for WUnderground weather service.
|
|
|
|
For more details about this platform, please refer to the documentation at
|
|
https://home-assistant.io/components/sensor.wunderground/
|
|
"""
|
|
from datetime import timedelta
|
|
import logging
|
|
|
|
import re
|
|
import requests
|
|
import voluptuous as vol
|
|
|
|
from homeassistant.components.sensor import PLATFORM_SCHEMA
|
|
from homeassistant.const import (
|
|
CONF_MONITORED_CONDITIONS, CONF_API_KEY, TEMP_FAHRENHEIT, TEMP_CELSIUS,
|
|
STATE_UNKNOWN, ATTR_ATTRIBUTION)
|
|
from homeassistant.helpers.entity import Entity
|
|
from homeassistant.util import Throttle
|
|
import homeassistant.helpers.config_validation as cv
|
|
|
|
_RESOURCE = 'http://api.wunderground.com/api/{}/conditions/{}/q/'
|
|
_ALERTS = 'http://api.wunderground.com/api/{}/alerts/{}/q/'
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
CONF_ATTRIBUTION = "Data provided by the WUnderground weather service"
|
|
CONF_PWS_ID = 'pws_id'
|
|
CONF_LANG = 'lang'
|
|
|
|
DEFAULT_LANG = 'EN'
|
|
|
|
MIN_TIME_BETWEEN_UPDATES_ALERTS = timedelta(minutes=15)
|
|
MIN_TIME_BETWEEN_UPDATES_OBSERVATION = timedelta(minutes=5)
|
|
|
|
# Sensor types are defined like: Name, units
|
|
SENSOR_TYPES = {
|
|
'alerts': ['Alerts', None],
|
|
'dewpoint_c': ['Dewpoint (°C)', TEMP_CELSIUS],
|
|
'dewpoint_f': ['Dewpoint (°F)', TEMP_FAHRENHEIT],
|
|
'dewpoint_string': ['Dewpoint Summary', None],
|
|
'feelslike_c': ['Feels Like (°C)', TEMP_CELSIUS],
|
|
'feelslike_f': ['Feels Like (°F)', TEMP_FAHRENHEIT],
|
|
'feelslike_string': ['Feels Like', None],
|
|
'heat_index_c': ['Dewpoint (°C)', TEMP_CELSIUS],
|
|
'heat_index_f': ['Dewpoint (°F)', TEMP_FAHRENHEIT],
|
|
'heat_index_string': ['Heat Index Summary', None],
|
|
'elevation': ['Elevation', 'ft'],
|
|
'location': ['Location', None],
|
|
'observation_time': ['Observation Time', None],
|
|
'precip_1hr_in': ['Precipation 1hr', 'in'],
|
|
'precip_1hr_metric': ['Precipation 1hr', 'mm'],
|
|
'precip_1hr_string': ['Precipation 1hr', None],
|
|
'precip_today_in': ['Precipation Today', 'in'],
|
|
'precip_today_metric': ['Precipitation Today', 'mm'],
|
|
'precip_today_string': ['Precipitation today', None],
|
|
'pressure_in': ['Pressure', 'in'],
|
|
'pressure_mb': ['Pressure', 'mb'],
|
|
'pressure_trend': ['Pressure Trend', None],
|
|
'relative_humidity': ['Relative Humidity', '%'],
|
|
'station_id': ['Station ID', None],
|
|
'solarradiation': ['Solar Radiation', None],
|
|
'temperature_string': ['Temperature Summary', None],
|
|
'temp_c': ['Temperature (°C)', TEMP_CELSIUS],
|
|
'temp_f': ['Temperature (°F)', TEMP_FAHRENHEIT],
|
|
'UV': ['UV', None],
|
|
'visibility_km': ['Visibility (km)', 'km'],
|
|
'visibility_mi': ['Visibility (miles)', 'mi'],
|
|
'weather': ['Weather Summary', None],
|
|
'wind_degrees': ['Wind Degrees', None],
|
|
'wind_dir': ['Wind Direction', None],
|
|
'wind_gust_kph': ['Wind Gust', 'kpH'],
|
|
'wind_gust_mph': ['Wind Gust', 'mpH'],
|
|
'wind_kph': ['Wind Speed', 'kpH'],
|
|
'wind_mph': ['Wind Speed', 'mpH'],
|
|
'wind_string': ['Wind Summary', None],
|
|
}
|
|
|
|
# Alert Attributes
|
|
ALERTS_ATTRS = [
|
|
'date',
|
|
'description',
|
|
'expires',
|
|
'message',
|
|
]
|
|
|
|
# Language Supported Codes
|
|
LANG_CODES = [
|
|
'AF', 'AL', 'AR', 'HY', 'AZ', 'EU',
|
|
'BY', 'BU', 'LI', 'MY', 'CA', 'CN',
|
|
'TW', 'CR', 'CZ', 'DK', 'DV', 'NL',
|
|
'EN', 'EO', 'ET', 'FA', 'FI', 'FR',
|
|
'FC', 'GZ', 'DL', 'KA', 'GR', 'GU',
|
|
'HT', 'IL', 'HI', 'HU', 'IS', 'IO',
|
|
'ID', 'IR', 'IT', 'JP', 'JW', 'KM',
|
|
'KR', 'KU', 'LA', 'LV', 'LT', 'ND',
|
|
'MK', 'MT', 'GM', 'MI', 'MR', 'MN',
|
|
'NO', 'OC', 'PS', 'GN', 'PL', 'BR',
|
|
'PA', 'PU', 'RO', 'RU', 'SR', 'SK',
|
|
'SL', 'SP', 'SI', 'SW', 'CH', 'TL',
|
|
'TT', 'TH', 'UA', 'UZ', 'VU', 'CY',
|
|
'SN', 'JI', 'YI',
|
|
]
|
|
|
|
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
|
|
vol.Required(CONF_API_KEY): cv.string,
|
|
vol.Optional(CONF_PWS_ID): cv.string,
|
|
vol.Optional(CONF_LANG, default=DEFAULT_LANG):
|
|
vol.All(vol.In(LANG_CODES)),
|
|
vol.Required(CONF_MONITORED_CONDITIONS, default=[]):
|
|
vol.All(cv.ensure_list, [vol.In(SENSOR_TYPES)]),
|
|
})
|
|
|
|
|
|
def setup_platform(hass, config, add_devices, discovery_info=None):
|
|
"""Setup the WUnderground sensor."""
|
|
rest = WUndergroundData(hass,
|
|
config.get(CONF_API_KEY),
|
|
config.get(CONF_PWS_ID),
|
|
config.get(CONF_LANG))
|
|
sensors = []
|
|
for variable in config[CONF_MONITORED_CONDITIONS]:
|
|
sensors.append(WUndergroundSensor(rest, variable))
|
|
|
|
try:
|
|
rest.update()
|
|
except ValueError as err:
|
|
_LOGGER.error("Received error from WUnderground: %s", err)
|
|
return False
|
|
|
|
add_devices(sensors)
|
|
|
|
return True
|
|
|
|
|
|
class WUndergroundSensor(Entity):
|
|
"""Implementing the WUnderground sensor."""
|
|
|
|
def __init__(self, rest, condition):
|
|
"""Initialize the sensor."""
|
|
self.rest = rest
|
|
self._condition = condition
|
|
|
|
@property
|
|
def name(self):
|
|
"""Return the name of the sensor."""
|
|
return "PWS_" + self._condition
|
|
|
|
@property
|
|
def state(self):
|
|
"""Return the state of the sensor."""
|
|
if self.rest.data:
|
|
|
|
if self._condition == 'elevation' and self._condition in \
|
|
self.rest.data['observation_location']:
|
|
return self.rest.data['observation_location'][self._condition]\
|
|
.split()[0]
|
|
|
|
if self._condition == 'location' and \
|
|
'full' in self.rest.data['display_location']:
|
|
return self.rest.data['display_location']['full']
|
|
|
|
if self._condition in self.rest.data:
|
|
if self._condition == 'relative_humidity':
|
|
return int(self.rest.data[self._condition][:-1])
|
|
else:
|
|
return self.rest.data[self._condition]
|
|
|
|
if self._condition == 'alerts':
|
|
if self.rest.alerts:
|
|
return len(self.rest.alerts)
|
|
else:
|
|
return 0
|
|
return STATE_UNKNOWN
|
|
|
|
@property
|
|
def device_state_attributes(self):
|
|
"""Return the state attributes."""
|
|
attrs = {}
|
|
|
|
attrs[ATTR_ATTRIBUTION] = CONF_ATTRIBUTION
|
|
|
|
if not self.rest.alerts or self._condition != 'alerts':
|
|
return attrs
|
|
|
|
multiple_alerts = len(self.rest.alerts) > 1
|
|
for data in self.rest.alerts:
|
|
for alert in ALERTS_ATTRS:
|
|
if data[alert]:
|
|
if multiple_alerts:
|
|
dkey = alert.capitalize() + '_' + data['type']
|
|
else:
|
|
dkey = alert.capitalize()
|
|
attrs[dkey] = data[alert]
|
|
return attrs
|
|
|
|
@property
|
|
def entity_picture(self):
|
|
"""Return the entity picture."""
|
|
if self.rest.data and self._condition == 'weather':
|
|
url = self.rest.data['icon_url']
|
|
return re.sub(r'^http://', 'https://', url, flags=re.IGNORECASE)
|
|
|
|
@property
|
|
def unit_of_measurement(self):
|
|
"""Return the units of measurement."""
|
|
return SENSOR_TYPES[self._condition][1]
|
|
|
|
def update(self):
|
|
"""Update current conditions."""
|
|
if self._condition == 'alerts':
|
|
self.rest.update_alerts()
|
|
else:
|
|
self.rest.update()
|
|
|
|
|
|
class WUndergroundData(object):
|
|
"""Get data from WUnderground."""
|
|
|
|
def __init__(self, hass, api_key, pws_id, lang):
|
|
"""Initialize the data object."""
|
|
self._hass = hass
|
|
self._api_key = api_key
|
|
self._pws_id = pws_id
|
|
self._lang = 'lang:{}'.format(lang)
|
|
self._latitude = hass.config.latitude
|
|
self._longitude = hass.config.longitude
|
|
self.data = None
|
|
self.alerts = None
|
|
|
|
def _build_url(self, baseurl=_RESOURCE):
|
|
url = baseurl.format(self._api_key, self._lang)
|
|
if self._pws_id:
|
|
url = url + 'pws:{}'.format(self._pws_id)
|
|
else:
|
|
url = url + '{},{}'.format(self._latitude, self._longitude)
|
|
|
|
return url + '.json'
|
|
|
|
@Throttle(MIN_TIME_BETWEEN_UPDATES_OBSERVATION)
|
|
def update(self):
|
|
"""Get the latest data from WUnderground."""
|
|
try:
|
|
result = requests.get(self._build_url(), timeout=10).json()
|
|
if "error" in result['response']:
|
|
raise ValueError(result['response']["error"]
|
|
["description"])
|
|
else:
|
|
self.data = result["current_observation"]
|
|
except ValueError as err:
|
|
_LOGGER.error("Check WUnderground API %s", err.args)
|
|
self.data = None
|
|
|
|
@Throttle(MIN_TIME_BETWEEN_UPDATES_ALERTS)
|
|
def update_alerts(self):
|
|
"""Get the latest alerts data from WUnderground."""
|
|
try:
|
|
result = requests.get(self._build_url(_ALERTS), timeout=10).json()
|
|
if "error" in result['response']:
|
|
raise ValueError(result['response']["error"]
|
|
["description"])
|
|
else:
|
|
self.alerts = result["alerts"]
|
|
except ValueError as err:
|
|
_LOGGER.error("Check WUnderground API %s", err.args)
|
|
self.alerts = None
|