Hello, j’essaie de voir pour modifier une intégration existante qui ne fonctionne pas comme j’aimerais.
En gros, c’est une integration qui va récupérer l’index de ma consommation d’eau, mais lorsque je l’affiche dans les graphiques énergie, il affiche les données au jour de lecture et non au jour correspondant à l’index.
l’extension de base, qui fonctionne mais ne stocke pas comme je voudrais l’index : GitHub - laurent-martin/hass_int_toutsurmoneau: Home assistant integration for Suez tout sur mon eau
j’ai modifier le sensor pour avoir la date qui correspond a l’index. Mais je n’arrive pas a l’utiliser correctement. Je voudrais qu’il stocker les données avec le bon jour. Pas le jour ou se fais le call.
'''Sensor for water provider portal.'''
from datetime import datetime, timedelta, date
import logging
import toutsurmoneau
from homeassistant.components.sensor import (
SensorDeviceClass,
SensorEntity,
SensorStateClass,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import UnitOfVolume
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from .const import (
DOMAIN,
)
_LOGGER = logging.getLogger(__name__)
# for hass
SCAN_INTERVAL = timedelta(hours=1)
async def async_setup_entry(
hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
) -> None:
'''Set up the meter sensor.'''
_LOGGER.debug('async_setup_entry')
# API object stored here by __init__.py
api: toutsurmoneau.AsyncClient = hass.data[DOMAIN][entry.entry_id]
account = (await api.async_contracts())[0]
async_add_entities([ToutSurMonEauEntity(api, account)])
class ToutSurMonEauEntity(SensorEntity):
'''Implementation of the meter sensor.'''
def __init__(self, api: toutsurmoneau.AsyncClient, account):
'''Initialize the ToutSurMonEauEntity class.'''
_LOGGER.debug('__init__')
self._name = f'{account['brandCode']} test-meter {api._id}'
self._unit_of_measurement = UnitOfVolume.LITERS
self._state = None
self._reading_date = None
self._attr_attribution = account['brandCode']
self._attr_should_poll = True
self._api = api
# Définir les attributs supplémentaires
@property
def extra_state_attributes(self):
'''Return additional attributes of the sensor.'''
return {
"reading_date": self._reading_date.isoformat() if self._reading_date else None,
}
@property
def device_class(self):
'''Return the device class.'''
_LOGGER.debug('device_class')
return SensorDeviceClass.WATER
@property
def state_class(self):
'''Return the state class.'''
_LOGGER.debug('state_class')
return SensorStateClass.TOTAL_INCREASING
@property
def name(self):
'''Return the name of the sensor.'''
_LOGGER.debug('name')
return self._name
@property
def unique_id(self):
'''Return sensor unique_id.'''
_LOGGER.debug('unique_id')
return 'unique_id_with_meter'
@property
def native_value(self):
'''Return the state of the device.'''
_LOGGER.debug('native_value')
return self._state
@property
def native_unit_of_measurement(self):
'''Return the unit of measurement of this entity, if any.'''
_LOGGER.debug('native_unit_of_measurement')
return self._unit_of_measurement
@property
def icon(self):
'''Return icon.'''
_LOGGER.debug('icon')
return 'mdi:water-pump'
@property
def usage(self):
'''Return ???.'''
_LOGGER.debug('usage')
return None
@property
def available(self):
'''Return if entity is available.'''
_LOGGER.debug('available')
# true if last update was successful (api available)
return True
async def async_added_to_hass(self) -> None:
'''When entity is added to hass.'''
_LOGGER.debug('async_added_to_hass')
async def async_update(self) -> None:
_LOGGER.debug("async_update")
data = await self._api.async_latest_meter_reading()
_LOGGER.debug("API response: %s", data)
volume = data['volume']
reading_date = data['date'] # C'est un objet datetime.date
reading_datetime = datetime.combine(reading_date, datetime.min.time())
_LOGGER.debug("Volume : %s", volume)
_LOGGER.debug("Reading date : %s", reading_date)
# Vérifiez que reading_date est bien un objet date
if isinstance(reading_date, date):
_LOGGER.debug("Reading date is valid: %s", reading_date)
# Mettez à jour l'état de l'entité
self._state = volume
self._reading_date = reading_date # Affecter la valeur à l'attribut _reading_date
# Vous pouvez aussi mettre à jour l'état global de l'entité ici si nécessaire
self.hass.states.async_set(
self.entity_id,
volume,
{
"reading_date": reading_date.isoformat(), # Attribut supplémentaire
},
timestamp=reading_datetime.timestamp()
)
else:
_LOGGER.error("Unexpected type for reading_date: %s", type(reading_date))