Home-Assistant
/
core
mirror of https://github.com/home-assistant/core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use EntityDescription - freebox (#55675) 

* Use EntityDescription - freebox

* Remove default values
pull/55696/head
Marc Mueller 2021-09-03 22:33:26 +02:00 committed by GitHub
parent 7111fc47c4
commit fbf812a845
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 84 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
homeassistant/components/freebox/const.py
View File

@ -1,12 +1,10 @@
"""Freebox component constants."""
from __future__ import annotations
import socket
from homeassistant.const import (
DATA_RATE_KILOBYTES_PER_SECOND,
DEVICE_CLASS_TEMPERATURE,
PERCENTAGE,
TEMP_CELSIUS,
)
from homeassistant.components.sensor import SensorEntityDescription
from homeassistant.const import DATA_RATE_KILOBYTES_PER_SECOND, PERCENTAGE
DOMAIN = "freebox"
SERVICE_REBOOT = "reboot"
@ -27,51 +25,39 @@ DEFAULT_DEVICE_NAME = "Unknown device"
STORAGE_KEY = DOMAIN
STORAGE_VERSION = 1
# Sensor
SENSOR_NAME = "name"
SENSOR_UNIT = "unit"
SENSOR_ICON = "icon"
SENSOR_DEVICE_CLASS = "device_class"
CONNECTION_SENSORS = {
"rate_down": {
SENSOR_NAME: "Freebox download speed",
SENSOR_UNIT: DATA_RATE_KILOBYTES_PER_SECOND,
SENSOR_ICON: "mdi:download-network",
SENSOR_DEVICE_CLASS: None,
},
"rate_up": {
SENSOR_NAME: "Freebox upload speed",
SENSOR_UNIT: DATA_RATE_KILOBYTES_PER_SECOND,
SENSOR_ICON: "mdi:upload-network",
SENSOR_DEVICE_CLASS: None,
},
}
CONNECTION_SENSORS: tuple[SensorEntityDescription, ...] = (
SensorEntityDescription(
key="rate_down",
name="Freebox download speed",
native_unit_of_measurement=DATA_RATE_KILOBYTES_PER_SECOND,
icon="mdi:download-network",
),
SensorEntityDescription(
key="rate_up",
name="Freebox upload speed",
native_unit_of_measurement=DATA_RATE_KILOBYTES_PER_SECOND,
icon="mdi:upload-network",
),
)
CONNECTION_SENSORS_KEYS: list[str] = [desc.key for desc in CONNECTION_SENSORS]
CALL_SENSORS = {
"missed": {
SENSOR_NAME: "Freebox missed calls",
SENSOR_UNIT: None,
SENSOR_ICON: "mdi:phone-missed",
SENSOR_DEVICE_CLASS: None,
},
}
CALL_SENSORS: tuple[SensorEntityDescription, ...] = (
SensorEntityDescription(
key="missed",
name="Freebox missed calls",
icon="mdi:phone-missed",
),
)
DISK_PARTITION_SENSORS = {
"partition_free_space": {
SENSOR_NAME: "free space",
SENSOR_UNIT: PERCENTAGE,
SENSOR_ICON: "mdi:harddisk",
SENSOR_DEVICE_CLASS: None,
},
}
TEMPERATURE_SENSOR_TEMPLATE = {
SENSOR_NAME: None,
SENSOR_UNIT: TEMP_CELSIUS,
SENSOR_ICON: "mdi:thermometer",
SENSOR_DEVICE_CLASS: DEVICE_CLASS_TEMPERATURE,
}
DISK_PARTITION_SENSORS: tuple[SensorEntityDescription, ...] = (
SensorEntityDescription(
key="partition_free_space",
name="free space",
native_unit_of_measurement=PERCENTAGE,
icon="mdi:harddisk",
),
)
# Icons
DEVICE_ICONS = {

4
homeassistant/components/freebox/router.py
View File

@ -24,7 +24,7 @@ from homeassistant.util import slugify
from .const import (
API_VERSION,
APP_DESC,
CONNECTION_SENSORS,
CONNECTION_SENSORS_KEYS,
DOMAIN,
STORAGE_KEY,
STORAGE_VERSION,
@ -141,7 +141,7 @@ class FreeboxRouter:
# Connection sensors
connection_datas: dict[str, Any] = await self._api.connection.get_status()
for sensor_key in CONNECTION_SENSORS:
for sensor_key in CONNECTION_SENSORS_KEYS:
self.sensors_connection[sensor_key] = connection_datas[sensor_key]
self._attrs = {

142
homeassistant/components/freebox/sensor.py
View File

@ -4,25 +4,19 @@ from __future__ import annotations
import logging
from typing import Any
from homeassistant.components.sensor import SensorEntity
from homeassistant.components.sensor import SensorEntity, SensorEntityDescription
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import DATA_RATE_KILOBYTES_PER_SECOND
from homeassistant.const import (
DATA_RATE_KILOBYTES_PER_SECOND,
DEVICE_CLASS_TEMPERATURE,
TEMP_CELSIUS,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import DeviceInfo
import homeassistant.util.dt as dt_util
from .const import (
CALL_SENSORS,
CONNECTION_SENSORS,
DISK_PARTITION_SENSORS,
DOMAIN,
SENSOR_DEVICE_CLASS,
SENSOR_ICON,
SENSOR_NAME,
SENSOR_UNIT,
TEMPERATURE_SENSOR_TEMPLATE,
)
from .const import CALL_SENSORS, CONNECTION_SENSORS, DISK_PARTITION_SENSORS, DOMAIN
from .router import FreeboxRouter
_LOGGER = logging.getLogger(__name__)
@ -41,34 +35,33 @@ async def async_setup_entry(
router.mac,
len(router.sensors_temperature),
)
for sensor_name in router.sensors_temperature:
entities.append(
FreeboxSensor(
router,
sensor_name,
{**TEMPERATURE_SENSOR_TEMPLATE, SENSOR_NAME: f"Freebox {sensor_name}"},
)
entities = [
FreeboxSensor(
router,
SensorEntityDescription(
key=sensor_name,
name=f"Freebox {sensor_name}",
native_unit_of_measurement=TEMP_CELSIUS,
device_class=DEVICE_CLASS_TEMPERATURE,
),
)
for sensor_name in router.sensors_temperature
]
for sensor_key, sensor in CONNECTION_SENSORS.items():
entities.append(FreeboxSensor(router, sensor_key, sensor))
for sensor_key, sensor in CALL_SENSORS.items():
entities.append(FreeboxCallSensor(router, sensor_key, sensor))
entities.extend(
[FreeboxSensor(router, description) for description in CONNECTION_SENSORS]
)
entities.extend(
[FreeboxCallSensor(router, description) for description in CALL_SENSORS]
)
_LOGGER.debug("%s - %s - %s disk(s)", router.name, router.mac, len(router.disks))
for disk in router.disks.values():
for partition in disk["partitions"]:
for sensor_key, sensor in DISK_PARTITION_SENSORS.items():
entities.append(
FreeboxDiskSensor(
router,
disk,
partition,
sensor_key,
sensor,
)
)
entities.extend(
FreeboxDiskSensor(router, disk, partition, description)
for disk in router.disks.values()
for partition in disk["partitions"]
for description in DISK_PARTITION_SENSORS
)
async_add_entities(entities, True)
@ -76,68 +69,30 @@ async def async_setup_entry(
class FreeboxSensor(SensorEntity):
"""Representation of a Freebox sensor."""
_attr_should_poll = False
def __init__(
self, router: FreeboxRouter, sensor_type: str, sensor: dict[str, Any]
self, router: FreeboxRouter, description: SensorEntityDescription
) -> None:
"""Initialize a Freebox sensor."""
self._state = None
self.entity_description = description
self._router = router
self._sensor_type = sensor_type
self._name = sensor[SENSOR_NAME]
self._unit = sensor[SENSOR_UNIT]
self._icon = sensor[SENSOR_ICON]
self._device_class = sensor[SENSOR_DEVICE_CLASS]
self._unique_id = f"{self._router.mac} {self._name}"
self._attr_unique_id = f"{router.mac} {description.name}"
@callback
def async_update_state(self) -> None:
"""Update the Freebox sensor."""
state = self._router.sensors[self._sensor_type]
if self._unit == DATA_RATE_KILOBYTES_PER_SECOND:
self._state = round(state / 1000, 2)
state = self._router.sensors[self.entity_description.key]
if self.native_unit_of_measurement == DATA_RATE_KILOBYTES_PER_SECOND:
self._attr_native_value = round(state / 1000, 2)
else:
self._state = state
@property
def unique_id(self) -> str:
"""Return a unique ID."""
return self._unique_id
@property
def name(self) -> str:
"""Return the name."""
return self._name
@property
def native_value(self) -> str:
"""Return the state."""
return self._state
@property
def native_unit_of_measurement(self) -> str:
"""Return the unit."""
return self._unit
@property
def icon(self) -> str:
"""Return the icon."""
return self._icon
@property
def device_class(self) -> str:
"""Return the device_class."""
return self._device_class
self._attr_native_value = state
@property
def device_info(self) -> DeviceInfo:
"""Return the device information."""
return self._router.device_info
@property
def should_poll(self) -> bool:
"""No polling needed."""
return False
@callback
def async_on_demand_update(self):
"""Update state."""
@ -160,10 +115,10 @@ class FreeboxCallSensor(FreeboxSensor):
"""Representation of a Freebox call sensor."""
def __init__(
self, router: FreeboxRouter, sensor_type: str, sensor: dict[str, Any]
self, router: FreeboxRouter, description: SensorEntityDescription
) -> None:
"""Initialize a Freebox call sensor."""
super().__init__(router, sensor_type, sensor)
super().__init__(router, description)
self._call_list_for_type = []
@callback
@ -174,10 +129,10 @@ class FreeboxCallSensor(FreeboxSensor):
for call in self._router.call_list:
if not call["new"]:
continue
if call["type"] == self._sensor_type:
if self.entity_description.key == call["type"]:
self._call_list_for_type.append(call)
self._state = len(self._call_list_for_type)
self._attr_native_value = len(self._call_list_for_type)
@property
def extra_state_attributes(self) -> dict[str, Any]:
@ -196,15 +151,14 @@ class FreeboxDiskSensor(FreeboxSensor):
router: FreeboxRouter,
disk: dict[str, Any],
partition: dict[str, Any],
sensor_type: str,
sensor: dict[str, Any],
description: SensorEntityDescription,
) -> None:
"""Initialize a Freebox disk sensor."""
super().__init__(router, sensor_type, sensor)
super().__init__(router, description)
self._disk = disk
self._partition = partition
self._name = f"{partition['label']} {sensor[SENSOR_NAME]}"
self._unique_id = f"{self._router.mac} {sensor_type} {self._disk['id']} {self._partition['id']}"
self._attr_name = f"{partition['label']} {description.name}"
self._unique_id = f"{self._router.mac} {description.key} {self._disk['id']} {self._partition['id']}"
@property
def device_info(self) -> DeviceInfo:
@ -223,6 +177,6 @@ class FreeboxDiskSensor(FreeboxSensor):
@callback
def async_update_state(self) -> None:
"""Update the Freebox disk sensor."""
self._state = round(
self._attr_native_value = round(
self._partition["free_bytes"] * 100 / self._partition["total_bytes"], 2
)