Add Netatmo data handler (#35571)

* Fix webhook registration

* Only load camera platform with valid scope

* Add initial data handler and netatmo base class

* Update camera to use data handler

* Update init

* Parallelize API calls

* Remove cruft

* Minor tweaks

* Refactor data handler

* Update climate to use data handler

* Fix pylint error

* Fix climate update not getting fresh data

* Update climate data

* update to pyatmo 4.0.0

* Refactor for pyatmo 4.0.0

* Exclude from coverage until tests are written

* Fix typo

* Reduce parallel calls

* Add heating request attr

* Async get_entities

* Undo parallel updates

* Fix camera issue

* Introduce individual scan interval per device class

* Some cleanup

* Add basic webhook support for climate to improve responsiveness

* Replace ClimateDevice by ClimateEntity

* Add support for turning camera on/off

* Update camera state upon webhook events

* Guard data class registration with lock

* Capture errors

* Add light platform

* Add dis-/connect handling

* Fix set schedule service

* Remove extra calls

* Add service to set person(s) home/away

* Add service descriptions

* Improve service descriptions

* Use LightEntity instead of Light

* Add guard if no data is retrieved

* Make services entity based

* Only raise platform not ready if there is a NOC

* Register webhook even during runtime

* Fix turning off event

* Fix linter error

* Fix linter error

* Exclude light platform from coverage

* Change log level

* Refactor public weather sensor to use data handler

* Prevent too short coordinates

* Ignore modules without _id

* Code cleanup

* Fix test

* Exit early if no home data is retrieved

* Prevent discovery if already active

* Add services to (un-)register webhook

* Fix tests

* Not actually a coroutine

* Move methods to base class

* Address pylint comment

* Address pylint complaints

* Address comments

* Address more comments

* Add docstring

* Use single instance allowed

* Extract method

* Remove cruft

* Write state directly

* Fix test

* Add file to coverage

* Move nested function

* Move nested function

* Update docstring

* Clean up code

* Fix webhook bug

* Clean up listeners

* Use deque

* Clean up prints

* Update homeassistant/components/netatmo/sensor.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/sensor.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/sensor.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/sensor.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/sensor.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/sensor.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/camera.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/camera.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/camera.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/camera.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/camera.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update homeassistant/components/netatmo/camera.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Rename data_class variable

* Break when match

* Extract method

* Extract methods

* Rename variable

* Improve comment

* Some refinements

* Extra

* Extract method

* Simplify code

* Improve reability

* Code simplification

* Simplify code

* Simplify code

* Code cleanup

* Fix import

* Clean up

* Clean up magic strings

* Replace data_class_name with CAMERA_DATA_CLASS_NAME

* Replace data_class_name with CAMERA_DATA_CLASS_NAME

* Replace data_class_name with HOMEDATA_DATA_CLASS_NAME

* Replace data_class_name in public weather sensor

* Clean up

* Remove deprecated config options

* Schedule immediate update on camera reconnect

* Use UUID to clearly identify public weather areas

* Use subscription mode

* Move clean up of temporary data classes

* Delay data class removal

* Fix linter complaints

* Adjust test

* Only setup lights if webhook are registered

* Prevent crash with old config entries

* Don't cache home ids

* Remove stale code

* Fix coordinates if entered mixed up by the user

* Move nested function

* Add test case for swapped coordinates

* Only wait for discovery entries

* Only use what I need

* Bring stuff closer to where it's used

* Auto clean up setup data classes

* Code cleanup

* Remove unneccessary lock

* Update homeassistant/components/netatmo/sensor.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Update tests/components/netatmo/test_config_flow.py

Co-authored-by: J. Nick Koston <nick@koston.org>

* Clean up dead code

* Fix formating

* Extend coverage

* Extend coverage

Co-authored-by: J. Nick Koston <nick@koston.org>
This commit is contained in:
cgtobiandJ. Nick Koston authored and GitHub committed 2020-08-04 20:46:46 +02:00
1 parent 0780650015
commit 31dbdff3c4
19 files changed
+1422 -846

No files matched your search

+304 -337
View File
@@ -1,15 +1,11 @@
"""Support for the Netatmo Weather Service."""
from datetime import timedelta
import logging
import pyatmo
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
ATTR_LATITUDE,
ATTR_LONGITUDE,
CONCENTRATION_PARTS_PER_MILLION,
CONF_SHOW_ON_MAP,
DEVICE_CLASS_BATTERY,
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_TEMPERATURE,
@@ -23,31 +19,18 @@ from homeassistant.helpers.dispatcher import (
async_dispatcher_connect,
async_dispatcher_send,
)
from homeassistant.helpers.entity import Entity
from homeassistant.util import Throttle
from .const import (
AUTH,
CONF_AREA_NAME,
CONF_LAT_NE,
CONF_LAT_SW,
CONF_LON_NE,
CONF_LON_SW,
CONF_PUBLIC_MODE,
CONF_WEATHER_AREAS,
DOMAIN,
MANUFACTURER,
MODELS,
from .const import CONF_WEATHER_AREAS, DATA_HANDLER, DOMAIN, MANUFACTURER, SIGNAL_NAME
from .data_handler import (
HOMECOACH_DATA_CLASS_NAME,
PUBLICDATA_DATA_CLASS_NAME,
WEATHERSTATION_DATA_CLASS_NAME,
)
from .helper import NetatmoArea
from .netatmo_entity_base import NetatmoBase
_LOGGER = logging.getLogger(__name__)
# This is the Netatmo data upload interval in seconds
NETATMO_UPDATE_INTERVAL = 600
# NetAtmo Public Data is uploaded to server every 10 minutes
MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=NETATMO_UPDATE_INTERVAL)
SUPPORTED_PUBLIC_SENSOR_TYPES = [
"temperature",
"pressure",
@@ -76,11 +59,11 @@ SENSOR_TYPES = {
DEVICE_CLASS_HUMIDITY,
],
"rain": ["Rain", "mm", "mdi:weather-rainy", None],
"sum_rain_1": ["sum_rain_1", "mm", "mdi:weather-rainy", None],
"sum_rain_24": ["sum_rain_24", "mm", "mdi:weather-rainy", None],
"sum_rain_1": ["Rain last hour", "mm", "mdi:weather-rainy", None],
"sum_rain_24": ["Rain last 24h", "mm", "mdi:weather-rainy", None],
"battery_vp": ["Battery", "", "mdi:battery", None],
"battery_lvl": ["Battery_lvl", "", "mdi:battery", None],
"battery_percent": ["battery_percent", UNIT_PERCENTAGE, None, DEVICE_CLASS_BATTERY],
"battery_lvl": ["Battery Level", "", "mdi:battery", None],
"battery_percent": ["Battery Percent", UNIT_PERCENTAGE, None, DEVICE_CLASS_BATTERY],
"min_temp": ["Min Temp.", TEMP_CELSIUS, "mdi:thermometer", None],
"max_temp": ["Max Temp.", TEMP_CELSIUS, "mdi:thermometer", None],
"windangle": ["Angle", "", "mdi:compass", None],
@@ -101,9 +84,9 @@ SENSOR_TYPES = {
],
"reachable": ["Reachability", "", "mdi:signal", None],
"rf_status": ["Radio", "", "mdi:signal", None],
"rf_status_lvl": ["Radio_lvl", "", "mdi:signal", None],
"rf_status_lvl": ["Radio Level", "", "mdi:signal", None],
"wifi_status": ["Wifi", "", "mdi:wifi", None],
"wifi_status_lvl": ["Wifi_lvl", "dBm", "mdi:wifi", None],
"wifi_status_lvl": ["Wifi Level", "dBm", "mdi:wifi", None],
"health_idx": ["Health", "", "mdi:cloud", None],
}
@@ -112,76 +95,110 @@ MODULE_TYPE_WIND = "NAModule2"
MODULE_TYPE_RAIN = "NAModule3"
MODULE_TYPE_INDOOR = "NAModule4"
NETATMO_DEVICE_TYPES = {
"WeatherStationData": "weather station",
"HomeCoachData": "home coach",
BATTERY_VALUES = {
MODULE_TYPE_WIND: {"Full": 5590, "High": 5180, "Medium": 4770, "Low": 4360},
MODULE_TYPE_RAIN: {"Full": 5500, "High": 5000, "Medium": 4500, "Low": 4000},
MODULE_TYPE_INDOOR: {"Full": 5500, "High": 5280, "Medium": 4920, "Low": 4560},
MODULE_TYPE_OUTDOOR: {"Full": 5500, "High": 5000, "Medium": 4500, "Low": 4000},
}
PUBLIC = "public"
async def async_setup_entry(
hass: HomeAssistant, entry: ConfigEntry, async_add_entities
):
async def async_setup_entry(hass, entry, async_add_entities):
"""Set up the Netatmo weather and homecoach platform."""
auth = hass.data[DOMAIN][entry.entry_id][AUTH]
device_registry = await hass.helpers.device_registry.async_get_registry()
data_handler = hass.data[DOMAIN][entry.entry_id][DATA_HANDLER]
def find_entities(data):
async def find_entities(data_class_name):
"""Find all entities."""
all_module_infos = data.get_module_infos()
await data_handler.register_data_class(data_class_name, data_class_name, None)
all_module_infos = {}
data = data_handler.data
if not data.get(data_class_name):
return []
data_class = data[data_class_name]
for station_id in data_class.stations:
for module_id in data_class.get_modules(station_id):
all_module_infos[module_id] = data_class.get_module(module_id)
all_module_infos[station_id] = data_class.get_station(station_id)
entities = []
for module in all_module_infos.values():
_LOGGER.debug("Adding module %s %s", module["module_name"], module["id"])
for condition in data.station_data.monitoredConditions(
moduleId=module["id"]
):
entities.append(NetatmoSensor(data, module, condition.lower()))
return entities
def get_entities():
"""Retrieve Netatmo entities."""
entities = []
for data_class in [pyatmo.WeatherStationData, pyatmo.HomeCoachData]:
try:
dc_data = data_class(auth)
_LOGGER.debug("%s detected!", NETATMO_DEVICE_TYPES[data_class.__name__])
data = NetatmoData(auth, dc_data)
except pyatmo.NoDevice:
_LOGGER.debug(
"No %s entities found", NETATMO_DEVICE_TYPES[data_class.__name__]
)
if "_id" not in module:
_LOGGER.debug("Skipping module %s", module.get("module_name"))
continue
entities.extend(find_entities(data))
_LOGGER.debug(
"Adding module %s %s", module.get("module_name"), module.get("_id"),
)
for condition in data_class.get_monitored_conditions(
module_id=module["_id"]
):
entities.append(
NetatmoSensor(
data_handler, data_class_name, module, condition.lower()
)
)
return entities
async_add_entities(await hass.async_add_executor_job(get_entities), True)
for data_class_name in [
WEATHERSTATION_DATA_CLASS_NAME,
HOMECOACH_DATA_CLASS_NAME,
]:
async_add_entities(await find_entities(data_class_name), True)
@callback
def add_public_entities():
async def add_public_entities(update=True):
"""Retrieve Netatmo public weather entities."""
entities = []
for area in entry.options.get(CONF_WEATHER_AREAS, {}).values():
data = NetatmoPublicData(
auth,
lat_ne=area[CONF_LAT_NE],
lon_ne=area[CONF_LON_NE],
lat_sw=area[CONF_LAT_SW],
lon_sw=area[CONF_LON_SW],
entities = {
device.name: device.id
for device in async_entries_for_config_entry(
device_registry, entry.entry_id
)
if device.model == "Public Weather stations"
}
new_entities = []
for area in [
NetatmoArea(**i) for i in entry.options.get(CONF_WEATHER_AREAS, {}).values()
]:
signal_name = f"{PUBLICDATA_DATA_CLASS_NAME}-{area.uuid}"
if area.area_name in entities:
entities.pop(area.area_name)
if update:
async_dispatcher_send(
hass, f"netatmo-config-{area.area_name}", area,
)
continue
await data_handler.register_data_class(
PUBLICDATA_DATA_CLASS_NAME,
signal_name,
None,
LAT_NE=area.lat_ne,
LON_NE=area.lon_ne,
LAT_SW=area.lat_sw,
LON_SW=area.lon_sw,
)
for sensor_type in SUPPORTED_PUBLIC_SENSOR_TYPES:
entities.append(NetatmoPublicSensor(area, data, sensor_type,))
new_entities.append(
NetatmoPublicSensor(data_handler, area, sensor_type)
)
for device in async_entries_for_config_entry(device_registry, entry.entry_id):
if device.model == "Public Weather stations":
device_registry.async_remove_device(device.id)
for device_id in entities.values():
device_registry.async_remove_device(device_id)
if entities:
async_add_entities(entities)
if new_entities:
async_add_entities(new_entities)
async_dispatcher_connect(
hass, f"signal-{DOMAIN}-public-update-{entry.entry_id}", add_public_entities
@@ -189,7 +206,7 @@ async def async_setup_entry(
entry.add_update_listener(async_config_entry_updated)
add_public_entities()
await add_public_entities(False)
async def async_config_entry_updated(hass: HomeAssistant, entry: ConfigEntry) -> None:
@@ -202,39 +219,42 @@ async def async_setup_platform(hass, config, async_add_entities, discovery_info=
return
class NetatmoSensor(Entity):
class NetatmoSensor(NetatmoBase):
"""Implementation of a Netatmo sensor."""
def __init__(self, netatmo_data, module_info, sensor_type):
def __init__(self, data_handler, data_class_name, module_info, sensor_type):
"""Initialize the sensor."""
self.netatmo_data = netatmo_data
super().__init__(data_handler)
self._data_classes.append(
{"name": data_class_name, SIGNAL_NAME: data_class_name}
)
self._id = module_info["_id"]
self._station_id = module_info.get("main_device", self._id)
station = self._data.get_station(self._station_id)
device = self._data.get_module(self._id)
device = self.netatmo_data.station_data.moduleById(mid=module_info["id"])
if not device:
# Assume it's a station if module can't be found
device = self.netatmo_data.station_data.stationById(sid=module_info["id"])
device = station
if device["type"] == "NHC":
self.module_name = module_info["station_name"]
if device["type"] in ("NHC", "NAMain"):
self._device_name = module_info["station_name"]
else:
self.module_name = (
f"{module_info['station_name']} {module_info['module_name']}"
)
self._device_name = f"{station['station_name']} {module_info.get('module_name', device['type'])}"
self._name = f"{MANUFACTURER} {self.module_name} {SENSOR_TYPES[sensor_type][0]}"
self._name = (
f"{MANUFACTURER} {self._device_name} {SENSOR_TYPES[sensor_type][0]}"
)
self.type = sensor_type
self._state = None
self._device_class = SENSOR_TYPES[self.type][3]
self._icon = SENSOR_TYPES[self.type][2]
self._unit_of_measurement = SENSOR_TYPES[self.type][1]
self._module_type = device["type"]
self._module_id = module_info["id"]
self._unique_id = f"{self._module_id}-{self.type}"
@property
def name(self):
"""Return the name of the sensor."""
return self._name
self._model = device["type"]
self._unique_id = f"{self._id}-{self.type}"
@property
def icon(self):
@@ -246,16 +266,6 @@ class NetatmoSensor(Entity):
"""Return the device class of the sensor."""
return self._device_class
@property
def device_info(self):
"""Return the device info for the sensor."""
return {
"identifiers": {(DOMAIN, self._module_id)},
"name": self.module_name,
"manufacturer": MANUFACTURER,
"model": MODELS[self._module_type],
}
@property
def state(self):
"""Return the state of the device."""
@@ -266,34 +276,33 @@ class NetatmoSensor(Entity):
"""Return the unit of measurement of this entity, if any."""
return self._unit_of_measurement
@property
def unique_id(self):
"""Return the unique ID for this sensor."""
return self._unique_id
@property
def available(self):
"""Return True if entity is available."""
"""Return entity availability."""
return self._state is not None
def update(self):
"""Get the latest data from Netatmo API and updates the states."""
self.netatmo_data.update()
if self.netatmo_data.data is None:
@callback
def async_update_callback(self):
"""Update the entity's state."""
if self._data is None:
if self._state is None:
return
_LOGGER.warning("No data from update")
self._state = None
return
data = self.netatmo_data.data.get(self._module_id)
data = self._data.get_last_data(station_id=self._station_id, exclude=3600).get(
self._id
)
if data is None:
if self._state:
_LOGGER.debug(
"No data found for %s (%s)", self.module_name, self._module_id
"No data (%s) found for %s (%s)",
self._data,
self._device_name,
self._id,
)
_LOGGER.debug("data: %s", self.netatmo_data.data)
self._state = None
return
@@ -318,50 +327,8 @@ class NetatmoSensor(Entity):
self._state = data["battery_percent"]
elif self.type == "battery_lvl":
self._state = data["battery_vp"]
elif self.type == "battery_vp" and self._module_type == MODULE_TYPE_WIND:
if data["battery_vp"] >= 5590:
self._state = "Full"
elif data["battery_vp"] >= 5180:
self._state = "High"
elif data["battery_vp"] >= 4770:
self._state = "Medium"
elif data["battery_vp"] >= 4360:
self._state = "Low"
elif data["battery_vp"] < 4360:
self._state = "Very Low"
elif self.type == "battery_vp" and self._module_type == MODULE_TYPE_RAIN:
if data["battery_vp"] >= 5500:
self._state = "Full"
elif data["battery_vp"] >= 5000:
self._state = "High"
elif data["battery_vp"] >= 4500:
self._state = "Medium"
elif data["battery_vp"] >= 4000:
self._state = "Low"
elif data["battery_vp"] < 4000:
self._state = "Very Low"
elif self.type == "battery_vp" and self._module_type == MODULE_TYPE_INDOOR:
if data["battery_vp"] >= 5640:
self._state = "Full"
elif data["battery_vp"] >= 5280:
self._state = "High"
elif data["battery_vp"] >= 4920:
self._state = "Medium"
elif data["battery_vp"] >= 4560:
self._state = "Low"
elif data["battery_vp"] < 4560:
self._state = "Very Low"
elif self.type == "battery_vp" and self._module_type == MODULE_TYPE_OUTDOOR:
if data["battery_vp"] >= 5500:
self._state = "Full"
elif data["battery_vp"] >= 5000:
self._state = "High"
elif data["battery_vp"] >= 4500:
self._state = "Medium"
elif data["battery_vp"] >= 4000:
self._state = "Low"
elif data["battery_vp"] < 4000:
self._state = "Very Low"
elif self.type == "battery_vp":
self._state = process_battery(data["battery_vp"], self._model)
elif self.type == "min_temp":
self._state = data["min_temp"]
elif self.type == "max_temp":
@@ -369,47 +336,13 @@ class NetatmoSensor(Entity):
elif self.type == "windangle_value":
self._state = data["WindAngle"]
elif self.type == "windangle":
if data["WindAngle"] >= 330:
self._state = "N (%d\xb0)" % data["WindAngle"]
elif data["WindAngle"] >= 300:
self._state = "NW (%d\xb0)" % data["WindAngle"]
elif data["WindAngle"] >= 240:
self._state = "W (%d\xb0)" % data["WindAngle"]
elif data["WindAngle"] >= 210:
self._state = "SW (%d\xb0)" % data["WindAngle"]
elif data["WindAngle"] >= 150:
self._state = "S (%d\xb0)" % data["WindAngle"]
elif data["WindAngle"] >= 120:
self._state = "SE (%d\xb0)" % data["WindAngle"]
elif data["WindAngle"] >= 60:
self._state = "E (%d\xb0)" % data["WindAngle"]
elif data["WindAngle"] >= 30:
self._state = "NE (%d\xb0)" % data["WindAngle"]
elif data["WindAngle"] >= 0:
self._state = "N (%d\xb0)" % data["WindAngle"]
self._state = process_angle(data["WindAngle"])
elif self.type == "windstrength":
self._state = data["WindStrength"]
elif self.type == "gustangle_value":
self._state = data["GustAngle"]
elif self.type == "gustangle":
if data["GustAngle"] >= 330:
self._state = "N (%d\xb0)" % data["GustAngle"]
elif data["GustAngle"] >= 300:
self._state = "NW (%d\xb0)" % data["GustAngle"]
elif data["GustAngle"] >= 240:
self._state = "W (%d\xb0)" % data["GustAngle"]
elif data["GustAngle"] >= 210:
self._state = "SW (%d\xb0)" % data["GustAngle"]
elif data["GustAngle"] >= 150:
self._state = "S (%d\xb0)" % data["GustAngle"]
elif data["GustAngle"] >= 120:
self._state = "SE (%d\xb0)" % data["GustAngle"]
elif data["GustAngle"] >= 60:
self._state = "E (%d\xb0)" % data["GustAngle"]
elif data["GustAngle"] >= 30:
self._state = "NE (%d\xb0)" % data["GustAngle"]
elif data["GustAngle"] >= 0:
self._state = "N (%d\xb0)" % data["GustAngle"]
self._state = process_angle(data["GustAngle"])
elif self.type == "guststrength":
self._state = data["GustStrength"]
elif self.type == "reachable":
@@ -417,90 +350,127 @@ class NetatmoSensor(Entity):
elif self.type == "rf_status_lvl":
self._state = data["rf_status"]
elif self.type == "rf_status":
if data["rf_status"] >= 90:
self._state = "Low"
elif data["rf_status"] >= 76:
self._state = "Medium"
elif data["rf_status"] >= 60:
self._state = "High"
elif data["rf_status"] <= 59:
self._state = "Full"
self._state = process_rf(data["rf_status"])
elif self.type == "wifi_status_lvl":
self._state = data["wifi_status"]
elif self.type == "wifi_status":
if data["wifi_status"] >= 86:
self._state = "Low"
elif data["wifi_status"] >= 71:
self._state = "Medium"
elif data["wifi_status"] >= 56:
self._state = "High"
elif data["wifi_status"] <= 55:
self._state = "Full"
self._state = process_wifi(data["wifi_status"])
elif self.type == "health_idx":
if data["health_idx"] == 0:
self._state = "Healthy"
elif data["health_idx"] == 1:
self._state = "Fine"
elif data["health_idx"] == 2:
self._state = "Fair"
elif data["health_idx"] == 3:
self._state = "Poor"
elif data["health_idx"] == 4:
self._state = "Unhealthy"
self._state = process_health(data["health_idx"])
except KeyError:
if self._state:
_LOGGER.info("No %s data found for %s", self.type, self.module_name)
_LOGGER.debug("No %s data found for %s", self.type, self._device_name)
self._state = None
return
class NetatmoData:
"""Get the latest data from Netatmo."""
def __init__(self, auth, station_data):
"""Initialize the data object."""
self.data = {}
self.station_data = station_data
self.auth = auth
def get_module_infos(self):
"""Return all modules available on the API as a dict."""
return self.station_data.getModules()
@Throttle(MIN_TIME_BETWEEN_UPDATES)
def update(self):
"""Call the Netatmo API to update the data."""
self.station_data = self.station_data.__class__(self.auth)
data = self.station_data.lastData(exclude=3600, byId=True)
if not data:
_LOGGER.debug("No data received when updating station data")
return
self.data = data
def process_angle(angle: int) -> str:
"""Process angle and return string for display."""
if angle >= 330:
return f"N ({angle}\xb0)"
if angle >= 300:
return f"NW ({angle}\xb0)"
if angle >= 240:
return f"W ({angle}\xb0)"
if angle >= 210:
return f"SW ({angle}\xb0)"
if angle >= 150:
return f"S ({angle}\xb0)"
if angle >= 120:
return f"SE ({angle}\xb0)"
if angle >= 60:
return f"E ({angle}\xb0)"
if angle >= 30:
return f"NE ({angle}\xb0)"
return f"N ({angle}\xb0)"
class NetatmoPublicSensor(Entity):
def process_battery(data: int, model: str) -> str:
"""Process battery data and return string for display."""
values = BATTERY_VALUES[model]
if data >= values["Full"]:
return "Full"
if data >= values["High"]:
return "High"
if data >= values["Medium"]:
return "Medium"
if data >= values["Low"]:
return "Low"
return "Very Low"
def process_health(health):
"""Process health index and return string for display."""
if health == 0:
return "Healthy"
if health == 1:
return "Fine"
if health == 2:
return "Fair"
if health == 3:
return "Poor"
if health == 4:
return "Unhealthy"
def process_rf(strength):
"""Process wifi signal strength and return string for display."""
if strength >= 90:
return "Low"
if strength >= 76:
return "Medium"
if strength >= 60:
return "High"
return "Full"
def process_wifi(strength):
"""Process wifi signal strength and return string for display."""
if strength >= 86:
return "Low"
if strength >= 71:
return "Medium"
if strength >= 56:
return "High"
return "Full"
class NetatmoPublicSensor(NetatmoBase):
"""Represent a single sensor in a Netatmo."""
def __init__(self, area, data, sensor_type):
def __init__(self, data_handler, area, sensor_type):
"""Initialize the sensor."""
self.netatmo_data = data
super().__init__(data_handler)
self._signal_name = f"{PUBLICDATA_DATA_CLASS_NAME}-{area.uuid}"
self._data_classes.append(
{
"name": PUBLICDATA_DATA_CLASS_NAME,
"LAT_NE": area.lat_ne,
"LON_NE": area.lon_ne,
"LAT_SW": area.lat_sw,
"LON_SW": area.lon_sw,
"area_name": area.area_name,
SIGNAL_NAME: self._signal_name,
}
)
self.type = sensor_type
self._mode = area[CONF_PUBLIC_MODE]
self._area_name = area[CONF_AREA_NAME]
self._name = f"{MANUFACTURER} {self._area_name} {SENSOR_TYPES[self.type][0]}"
self.area = area
self._mode = area.mode
self._area_name = area.area_name
self._id = self._area_name
self._device_name = f"{self._area_name}"
self._name = f"{MANUFACTURER} {self._device_name} {SENSOR_TYPES[self.type][0]}"
self._state = None
self._device_class = SENSOR_TYPES[self.type][3]
self._icon = SENSOR_TYPES[self.type][2]
self._unit_of_measurement = SENSOR_TYPES[self.type][1]
self._show_on_map = area[CONF_SHOW_ON_MAP]
self._unique_id = f"{self._name.replace(' ', '-')}"
self._module_type = PUBLIC
@property
def name(self):
"""Return the name of the sensor."""
return self._name
self._show_on_map = area.show_on_map
self._unique_id = f"{self._device_name.replace(' ', '-')}-{self.type}"
self._model = PUBLIC
@property
def icon(self):
@@ -512,28 +482,14 @@ class NetatmoPublicSensor(Entity):
"""Return the device class of the sensor."""
return self._device_class
@property
def device_info(self):
"""Return the device info for the sensor."""
return {
"identifiers": {(DOMAIN, self._area_name)},
"name": self._area_name,
"manufacturer": MANUFACTURER,
"model": MODELS[self._module_type],
}
@property
def device_state_attributes(self):
"""Return the attributes of the device."""
attrs = {}
if self._show_on_map:
attrs[ATTR_LATITUDE] = (
self.netatmo_data.lat_ne + self.netatmo_data.lat_sw
) / 2
attrs[ATTR_LONGITUDE] = (
self.netatmo_data.lon_ne + self.netatmo_data.lon_sw
) / 2
attrs[ATTR_LATITUDE] = (self.area.lat_ne + self.area.lat_sw) / 2
attrs[ATTR_LONGITUDE] = (self.area.lon_ne + self.area.lon_sw) / 2
return attrs
@@ -547,46 +503,95 @@ class NetatmoPublicSensor(Entity):
"""Return the unit of measurement of this entity."""
return self._unit_of_measurement
@property
def unique_id(self):
"""Return the unique ID for this sensor."""
return self._unique_id
@property
def available(self):
"""Return True if entity is available."""
return self._state is not None
def update(self):
"""Get the latest data from Netatmo API and updates the states."""
self.netatmo_data.update()
@property
def _data(self):
return self.data_handler.data[self._signal_name]
if self.netatmo_data.data is None:
_LOGGER.info("No data found for %s", self._name)
async def async_added_to_hass(self) -> None:
"""Entity created."""
await super().async_added_to_hass()
self.data_handler.listeners.append(
async_dispatcher_connect(
self.hass,
f"netatmo-config-{self.device_info['name']}",
self.async_config_update_callback,
)
)
@callback
async def async_config_update_callback(self, area):
"""Update the entity's config."""
if self.area == area:
return
await self.data_handler.unregister_data_class(
self._signal_name, self.async_update_callback
)
self.area = area
self._signal_name = f"{PUBLICDATA_DATA_CLASS_NAME}-{area.uuid}"
self._data_classes = [
{
"name": PUBLICDATA_DATA_CLASS_NAME,
"LAT_NE": area.lat_ne,
"LON_NE": area.lon_ne,
"LAT_SW": area.lat_sw,
"LON_SW": area.lon_sw,
"area_name": area.area_name,
SIGNAL_NAME: self._signal_name,
}
]
self._mode = area.mode
self._show_on_map = area.show_on_map
await self.data_handler.register_data_class(
PUBLICDATA_DATA_CLASS_NAME,
self._signal_name,
self.async_update_callback,
LAT_NE=area.lat_ne,
LON_NE=area.lon_ne,
LAT_SW=area.lat_sw,
LON_SW=area.lon_sw,
)
@callback
def async_update_callback(self):
"""Update the entity's state."""
if self._data is None:
if self._state is None:
return
_LOGGER.warning("No data from update")
self._state = None
return
data = None
if self.type == "temperature":
data = self.netatmo_data.data.getLatestTemperatures()
data = self._data.get_latest_temperatures()
elif self.type == "pressure":
data = self.netatmo_data.data.getLatestPressures()
data = self._data.get_latest_pressures()
elif self.type == "humidity":
data = self.netatmo_data.data.getLatestHumidities()
data = self._data.get_latest_humidities()
elif self.type == "rain":
data = self.netatmo_data.data.getLatestRain()
data = self._data.get_latest_rain()
elif self.type == "sum_rain_1":
data = self.netatmo_data.data.get60minRain()
data = self._data.get_60_min_rain()
elif self.type == "sum_rain_24":
data = self.netatmo_data.data.get24hRain()
data = self._data.get_24_h_rain()
elif self.type == "windstrength":
data = self.netatmo_data.data.getLatestWindStrengths()
data = self._data.get_latest_wind_strengths()
elif self.type == "guststrength":
data = self.netatmo_data.data.getLatestGustStrengths()
data = self._data.get_latest_gust_strengths()
if not data:
_LOGGER.warning(
if self._state is None:
return
_LOGGER.debug(
"No station provides %s data in the area %s", self.type, self._area_name
)
self._state = None
@@ -597,41 +602,3 @@ class NetatmoPublicSensor(Entity):
self._state = round(sum(values) / len(values), 1)
elif self._mode == "max":
self._state = max(values)
class NetatmoPublicData:
"""Get the latest data from Netatmo."""
def __init__(self, auth, lat_ne, lon_ne, lat_sw, lon_sw):
"""Initialize the data object."""
self.auth = auth
self.data = None
self.lat_ne = lat_ne
self.lon_ne = lon_ne
self.lat_sw = lat_sw
self.lon_sw = lon_sw
@Throttle(MIN_TIME_BETWEEN_UPDATES)
def update(self):
"""Request an update from the Netatmo API."""
try:
data = pyatmo.PublicData(
self.auth,
LAT_NE=self.lat_ne,
LON_NE=self.lon_ne,
LAT_SW=self.lat_sw,
LON_SW=self.lon_sw,
filtering=True,
)
except pyatmo.NoDevice:
data = None
if not data:
_LOGGER.debug("No data received when updating public station data")
return
if data.CountStationInArea() == 0:
_LOGGER.warning("No Stations available in this area")
return
self.data = data