Add coronavirus integration (#32413)

* Add coronavirus integration

* Update homeassistant/components/coronavirus/manifest.json

Co-Authored-By: Franck Nijhof <git@frenck.dev>

Co-authored-by: Franck Nijhof <frenck@frenck.nl>
This commit is contained in:
authored and GitHub committed 2020-03-02 13:40:11 -08:00
1 parent 2ba514253c
commit 1603f7ac21
13 files changed
+271

No files matched your search

@@ -0,0 +1,13 @@
{
"config": {
"step": {
"user": {
"data": {
"country": "Country"
},
"title": "Pick a country to monitor"
}
},
"title": "Coronavirus"
}
}
@@ -0,0 +1,75 @@
"""The Coronavirus integration."""
import asyncio
from datetime import timedelta
import logging
import aiohttp
import async_timeout
import coronavirus
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.helpers import aiohttp_client, update_coordinator
from .const import DOMAIN
PLATFORMS = ["sensor"]
async def async_setup(hass: HomeAssistant, config: dict):
"""Set up the Coronavirus component."""
# Make sure coordinator is initialized.
await get_coordinator(hass)
return True
async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry):
"""Set up Coronavirus from a config entry."""
for component in PLATFORMS:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, component)
)
return True
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
"""Unload a config entry."""
unload_ok = all(
await asyncio.gather(
*[
hass.config_entries.async_forward_entry_unload(entry, component)
for component in PLATFORMS
]
)
)
return unload_ok
async def get_coordinator(hass):
"""Get the data update coordinator."""
if DOMAIN in hass.data:
return hass.data[DOMAIN]
async def async_get_cases():
try:
with async_timeout.timeout(10):
return {
case.id: case
for case in await coronavirus.get_cases(
aiohttp_client.async_get_clientsession(hass)
)
}
except (asyncio.TimeoutError, aiohttp.ClientError):
raise update_coordinator.UpdateFailed
hass.data[DOMAIN] = update_coordinator.DataUpdateCoordinator(
hass,
logging.getLogger(__name__),
name=DOMAIN,
update_method=async_get_cases,
update_interval=timedelta(hours=1),
)
await hass.data[DOMAIN].async_refresh()
return hass.data[DOMAIN]
@@ -0,0 +1,41 @@
"""Config flow for Coronavirus integration."""
import logging
import voluptuous as vol
from homeassistant import config_entries
from . import get_coordinator
from .const import DOMAIN, OPTION_WORLDWIDE # pylint:disable=unused-import
_LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Coronavirus."""
VERSION = 1
CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
_options = None
async def async_step_user(self, user_input=None):
"""Handle the initial step."""
errors = {}
if self._options is None:
self._options = {OPTION_WORLDWIDE: "Worldwide"}
coordinator = await get_coordinator(self.hass)
for case_id in sorted(coordinator.data):
self._options[case_id] = coordinator.data[case_id].country
if user_input is not None:
return self.async_create_entry(
title=self._options[user_input["country"]], data=user_input
)
return self.async_show_form(
step_id="user",
data_schema=vol.Schema({vol.Required("country"): vol.In(self._options)}),
errors=errors,
)
@@ -0,0 +1,6 @@
"""Constants for the Coronavirus integration."""
from coronavirus import DEFAULT_SOURCE
DOMAIN = "coronavirus"
OPTION_WORLDWIDE = "__worldwide"
ATTRIBUTION = f"Data provided by {DEFAULT_SOURCE.NAME}"
@@ -0,0 +1,12 @@
{
"domain": "coronavirus",
"name": "Coronavirus (COVID-19)",
"config_flow": true,
"documentation": "https://www.home-assistant.io/integrations/coronavirus",
"requirements": ["coronavirus==1.0.1"],
"ssdp": [],
"zeroconf": [],
"homekit": {},
"dependencies": [],
"codeowners": ["@home_assistant/core"]
}
@@ -0,0 +1,69 @@
"""Sensor platform for the Corona virus."""
from homeassistant.const import ATTR_ATTRIBUTION
from homeassistant.helpers.entity import Entity
from . import get_coordinator
from .const import ATTRIBUTION, OPTION_WORLDWIDE
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Defer sensor setup to the shared sensor module."""
coordinator = await get_coordinator(hass)
async_add_entities(
CoronavirusSensor(coordinator, config_entry.data["country"], info_type)
for info_type in ("confirmed", "recovered", "deaths", "current")
)
class CoronavirusSensor(Entity):
"""Sensor representing corona virus data."""
name = None
unique_id = None
def __init__(self, coordinator, country, info_type):
"""Initialize coronavirus sensor."""
if country == OPTION_WORLDWIDE:
self.name = f"Worldwide {info_type}"
else:
self.name = f"{coordinator.data[country].country} {info_type}"
self.unique_id = f"{country}-{info_type}"
self.coordinator = coordinator
self.country = country
self.info_type = info_type
@property
def available(self):
"""Return if sensor is available."""
return self.coordinator.last_update_success and (
self.country in self.coordinator.data or self.country == OPTION_WORLDWIDE
)
@property
def state(self):
"""State of the sensor."""
if self.country == OPTION_WORLDWIDE:
return sum(
getattr(case, self.info_type) for case in self.coordinator.data.values()
)
return getattr(self.coordinator.data[self.country], self.info_type)
@property
def unit_of_measurement(self):
"""Return unit of measurement."""
return "people"
@property
def device_state_attributes(self):
"""Return device attributes."""
return {ATTR_ATTRIBUTION: ATTRIBUTION}
async def async_added_to_hass(self):
"""When entity is added to hass."""
self.coordinator.async_add_listener(self.async_write_ha_state)
async def async_will_remove_from_hass(self):
"""When entity will be removed from hass."""
self.coordinator.async_remove_listener(self.async_write_ha_state)
@@ -0,0 +1,13 @@
{
"config": {
"title": "Coronavirus",
"step": {
"user": {
"title": "Pick a country to monitor",
"data": {
"country": "Country"
}
}
}
}
}