add sources to custom_components

custom_components/sensor.py

@@ -0,0 +1,111 @@
+""" Implementation du composant sensors """
+import logging
+from datetime import datetime, timedelta
+
+from homeassistant.core import HomeAssistant, callback, Event, State
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.helpers.entity import EntityCategory
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+from homeassistant.components.sensor import (
+    SensorEntity,
+    SensorDeviceClass,
+    SensorStateClass,
+)
+from  homeassistant.helpers.event import (
+    async_track_time_interval,
+    async_track_state_change_event,
+)
+from .const import (
+    DOMAIN
+)
+from homeassistant.const import UnitOfTime
+from .koolnova.device import Koolnova
+
+_LOGGER = logging.getLogger(__name__)
+
+async def async_setup_entry(hass: HomeAssistant,
+                            entry: ConfigEntry,
+                            async_add_entities: AddEntitiesCallback):
+    """ Configuration des entités sensor à partir de la configuration
+        ConfigEntry passée en argument
+    """
+    _LOGGER.debug("Calling async_setup_entry - datas: {}".format(entry.data))
+    _LOGGER.debug("HASS data: {}".format(hass.data[DOMAIN]))
+    for device in hass.data[DOMAIN]:
+        _LOGGER.debug("Device: {}".format(device))
+        entities = [
+            DiagnosticsSensor(device, "Device", entry.data),
+            DiagnosticsSensor(device, "Address", entry.data),
+            DiagnosticsSensor(device, "Baudrate", entry.data),
+            DiagnosticsSensor(device, "Sizebyte", entry.data),
+            DiagnosticsSensor(device, "Parity", entry.data),
+            DiagnosticsSensor(device, "Stopbits", entry.data),
+            DiagnosticsSensor(device, "Timeout", entry.data),
+        ]
+        async_add_entities(entities)
+
+class DiagnosticsSensor(SensorEntity):
+    # pylint: disable = too-many-instance-attributes
+    """ Representation of a Sensor """
+
+    _attr_entity_category: EntityCategory | None = EntityCategory.DIAGNOSTIC
+
+    def __init__(self,
+                    device: Koolnova, # pylint: disable=unused-argument,
+                    name:str, # pylint: disable=unused-argument
+                    entry_infos, # pylint: disable=unused-argument
+                    ) -> None:
+        """ Class constructor """
+        self._device = device
+        self._attr_name = f"{device.name} {name}"
+        self._attr_entity_registry_enabled_default = True
+        self._attr_device_info = self._device.device_info
+        self._attr_unique_id = f"{DOMAIN}-{name}-sensor"
+        self._attr_native_value = entry_infos.get(name)
+
+    async def async_update(self):
+        """ Retreive latest state. """
+        _LOGGER.debug("[DIAG SENSOR] call async_update")
+
+    @property
+    def icon(self) -> str | None:
+        return "mdi:monitor"
+
+    @property
+    def should_poll(self) -> bool:
+        """ Do not poll for those entities """
+        return False
+
+class TestVBEElapsedSecondEntity(SensorEntity):
+    """ La classe de l'entité TestVBE_4 """
+
+    def __init__(self, 
+                    hass: HomeAssistant, #pylint: disable=unused-argument
+                    entry_infos, #pylint: disable=unused-argument
+                ) -> None:
+        """ Class constructor """
+        self._attr_name = entry_infos.get("name")
+        self._attr_unique_id = entry_infos.get("entity_id")
+        self._attr_has_entity_name = True
+        self._attr_native_value = 36
+
+    @property
+    def icon(self) -> str | None:
+        return "mdi:timer-play"
+
+    @property
+    def device_class(self) -> SensorDeviceClass | None:
+        return SensorDeviceClass.DURATION
+    
+    @property
+    def state_class(self) -> SensorStateClass | None:
+        return SensorStateClass.MEASUREMENT
+
+    @property
+    def native_unit_of_measurement(self) -> str | None:
+        return UnitOfTime.SECONDS
+    
+    @property
+    def should_poll(self) -> bool:
+        """ Do not poll for those entities """
+        return False