class AirlyDataUpdateCoordinator(DataUpdateCoordinator):
"""Define an object to hold Airly data."""
def __init__(
self,
hass,
session,
api_key,
latitude,
longitude,
update_interval,
use_nearest,
):
"""Initialize."""
self.latitude = latitude
self.longitude = longitude
self.airly = Airly(api_key, session)
self.use_nearest = use_nearest
super().__init__(hass, _LOGGER, name=DOMAIN, update_interval=update_interval)
async def _async_update_data(self):
"""Update data via library."""
data = {}
if self.use_nearest:
measurements = self.airly.create_measurements_session_nearest(
self.latitude, self.longitude, max_distance_km=5
)
else:
measurements = self.airly.create_measurements_session_point(
self.latitude, self.longitude
)
with async_timeout.timeout(20):
try:
await measurements.update()
except (AirlyError, ClientConnectorError) as error:
raise UpdateFailed(error) from error
_LOGGER.debug(
"Requests remaining: %s/%s",
self.airly.requests_remaining,
self.airly.requests_per_day,
)
values = measurements.current["values"]
index = measurements.current["indexes"][0]
standards = measurements.current["standards"]
if index["description"] == NO_AIRLY_SENSORS:
raise UpdateFailed("Can't retrieve data: no Airly sensors in this area")
for value in values:
data[value["name"]] = value["value"]
for standard in standards:
data[f"{standard['pollutant']}_LIMIT"] = standard["limit"]
data[f"{standard['pollutant']}_PERCENT"] = standard["percent"]
data[ATTR_API_CAQI] = index["value"]
data[ATTR_API_CAQI_LEVEL] = index["level"].lower().replace("_", " ")
data[ATTR_API_CAQI_DESCRIPTION] = index["description"]
data[ATTR_API_ADVICE] = index["advice"]
return data
async def _test_api_key(self, client, api_key):
"""Return true if api_key is valid."""
with async_timeout.timeout(10):
airly = Airly(api_key, client)
measurements = airly.create_measurements_session_point(
latitude=52.24131, longitude=20.99101)
try:
await measurements.update()
except AirlyError:
return False
return True
async def _test_location(self, client, api_key, latitude, longitude):
"""Return true if location is valid."""
with async_timeout.timeout(10):
airly = Airly(api_key, client)
measurements = airly.create_measurements_session_point(
latitude=latitude, longitude=longitude)
await measurements.update()
current = measurements.current
if current["indexes"][0]["description"] == NO_AIRLY_SENSORS:
return False
return True
class AirlyData:
"""Define an object to hold Airly data."""
def __init__(self, session, api_key, latitude, longitude):
"""Initialize."""
self.latitude = latitude
self.longitude = longitude
self.airly = Airly(api_key, session)
self.data = {}
@Throttle(DEFAULT_SCAN_INTERVAL)
async def async_update(self):
"""Update Airly data."""
try:
with async_timeout.timeout(10):
measurements = self.airly.create_measurements_session_point(
self.latitude, self.longitude)
await measurements.update()
values = measurements.current["values"]
index = measurements.current["indexes"][0]
standards = measurements.current["standards"]
if index["description"] == NO_AIRLY_SENSORS:
_LOGGER.error(
"Can't retrieve data: no Airly sensors in this area")
return
for value in values:
self.data[value["name"]] = value["value"]
for standard in standards:
self.data[f"{standard['pollutant']}_LIMIT"] = standard["limit"]
self.data[f"{standard['pollutant']}_PERCENT"] = standard[
"percent"]
self.data[ATTR_API_CAQI] = index["value"]
self.data[ATTR_API_CAQI_LEVEL] = index["level"].lower().replace(
"_", " ")
self.data[ATTR_API_CAQI_DESCRIPTION] = index["description"]
self.data[ATTR_API_ADVICE] = index["advice"]
_LOGGER.debug("Data retrieved from Airly")
except (
ValueError,
AirlyError,
asyncio.TimeoutError,
ClientConnectorError,
) as error:
_LOGGER.error(error)
self.data = {}
class AirlyDataUpdateCoordinator(DataUpdateCoordinator):
"""Class to manage fetching Airly data API."""
def __init__(
self, hass, session, api_key, latitude, longitude, language, scan_interval
):
"""Initialize."""
self.airly = Airly(api_key, session, language=language)
self.language = language
self.latitude = latitude
self.longitude = longitude
super().__init__(hass, _LOGGER, name=DOMAIN, update_interval=scan_interval)
async def _async_update_data(self):
"""Update data via library."""
data = {}
with timeout(20):
measurements = self.airly.create_measurements_session_point(
self.latitude, self.longitude
)
try:
await measurements.update()
except (AirlyError, ClientConnectorError) as error:
raise UpdateFailed(error) from error
values = measurements.current["values"]
index = measurements.current["indexes"][0]
standards = measurements.current["standards"]
if index["description"] == NO_AIRLY_SENSORS:
raise UpdateFailed("Can't retrieve data: no Airly sensors in this area")
for value in values:
data[value["name"]] = value["value"]
for standard in standards:
data[f"{standard['pollutant']}_LIMIT"] = standard["limit"]
data[f"{standard['pollutant']}_PERCENT"] = standard["percent"]
data[ATTR_CAQI] = index["value"]
data[ATTR_CAQI_LEVEL] = index["level"].lower().replace("_", " ")
data[ATTR_CAQI_DESCRIPTION] = index["description"]
data[ATTR_CAQI_ADVICE] = index["advice"]
return data
async def test_location(client,
api_key,
latitude,
longitude,
use_nearest=False):
"""Return true if location is valid."""
airly = Airly(api_key, client)
if use_nearest:
measurements = airly.create_measurements_session_nearest(
latitude=latitude, longitude=longitude, max_distance_km=5)
else:
measurements = airly.create_measurements_session_point(
latitude=latitude, longitude=longitude)
with async_timeout.timeout(10):
await measurements.update()
current = measurements.current
if current["indexes"][0]["description"] == NO_AIRLY_SENSORS["en"]:
return False
return True
async def main():
pyairly_logger = logging.getLogger('pyairly')
pyairly_logger.setLevel(logging.DEBUG)
pyairly_logger.addHandler(logging.StreamHandler(sys.stdout))
async with aiohttp.ClientSession() as http_session:
airly = Airly(API_KEY, http_session)
measurements_clients = OrderedDict([
('for specific installation',
airly.create_measurements_session_installation(2764)),
('for nearest installation',
airly.create_measurements_session_nearest(LATITUDE, LONGITUDE)),
('interpolated for specific point',
airly.create_measurements_session_point(LATITUDE, LONGITUDE))
])
for description, client in measurements_clients.items():
print()
sys.stdout.flush()
await client.update()
sys.stdout.flush()
current = client.current
print("Measurements %s:" % description)
for m in Measurement.MEASUREMENTS_TYPES:
print("%s: %s" % (m, current.values.get(m)))