v2.0.1, Fixing sensor update #9

custom_components/pixometer/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_polling",
   "issue_tracker": "https://github.com/myTselection/pixometer/issues",
   "requirements": [],
-  "version": "1.0.4"
+  "version": "2.0.1"
 }

custom_components/pixometer/sensor.py

@@ -26,7 +26,7 @@
 )
 
 #TODO check if needed
-MIN_TIME_BETWEEN_UPDATES = timedelta(hours=1)
+MIN_TIME_BETWEEN_UPDATES = timedelta(minutes=2)
 
 
 async def dry_setup(hass, config_entry, async_add_devices):
@@ -41,11 +41,12 @@ async def dry_setup(hass, config_entry, async_add_devices):
         hass
     )
 
-    meter_list = await data.initiate()
+    # meter_list = await data.initiate()
+    meter_list = await data._init_meter_list()
 
     for meter_details in meter_list.get("results"):
         sensors = []
-        meter_reading = await data.init_meter_readings(meter_details.get("meter_id"))
+        meter_reading = await data.update_meter_readings(meter_details.get("meter_id"))
         sensor = Component(data, meter_details, meter_reading, hass)
         sensors.append(sensor)
         async_add_devices(sensors)
@@ -85,8 +86,40 @@ def __init__(self, username, password, hass):
         self._hass = hass
         self._meter_readings = dict()
 
-    async def initiate(self):
-        _LOGGER.info("Fetching stuff for " + NAME)
+    # async def initiate(self):
+    #     _LOGGER.info("Fetching stuff for " + NAME)
+    #     if not(self._session):
+    #         self._session = ComponentSession()
+
+    #     if self._session:
+    #         await self._hass.async_add_executor_job(lambda: self._session.login(self._username, self._password))
+    #         _LOGGER.debug("login completed " + NAME)
+    #         self._meter_list = None
+    #         self._meter_list = await self._hass.async_add_executor_job(lambda: self._session.meterlist())
+    #         _LOGGER.debug("meter list retrieved " + NAME)    
+    #         assert self._meter_list is not None
+    #     return self._meter_list
+
+
+    # @Throttle(MIN_TIME_BETWEEN_UPDATES)
+    # async def _update(self, meter_id):
+    #     if not(self._session):
+    #         self._session = ComponentSession()
+
+    #     if self._session:
+    #         await self._hass.async_add_executor_job(lambda: self._session.login(self._username, self._password))
+    #         meter_readings = await self._hass.async_add_executor_job(lambda: self._session.meter_readings(meter_id))
+    #         _LOGGER.debug(f"updated meter readings for {NAME} - meter id: {meter_id}") 
+    #         assert meter_readings is not None
+    #         self._meter_readings[meter_id] = meter_readings.get("results")[0]
+
+    # async def update(self, meter_id):
+    #     await self._update(meter_id)
+    #     _LOGGER.debug(f"updated meter readings for {NAME} - meter id: {meter_id} - result: {self._meter_readings.get(meter_id)}") 
+    #     return self._meter_readings.get(meter_id)
+
+    async def _init_meter_list(self):
+        _LOGGER.info("Forced updated for " + NAME)
         if not(self._session):
             self._session = ComponentSession()
 
@@ -97,32 +130,39 @@ async def initiate(self):
             self._meter_list = await self._hass.async_add_executor_job(lambda: self._session.meterlist())
             _LOGGER.debug("meter list retrieved " + NAME)    
             assert self._meter_list is not None
-        return self._meter_list
-
-    async def init_meter_readings(self, meter_id):
+            return self._meter_list
+
+
+    # same as update, but without throttle to make sure init is always executed
+    async def _forced_update(self):
+        _LOGGER.info("Forced updated for " + NAME)
+        if not(self._session):
+            self._session = ComponentSession()
+
+        if self._session:
+            await self._hass.async_add_executor_job(lambda: self._session.login(self._username, self._password))
+            _LOGGER.debug("login completed " + NAME)
+
+            for meter_details in self._meter_list.get("results"):
+                await self.update_meter_readings(meter_details.get("meter_id"))
+
+
+    async def update_meter_readings(self, meter_id):
         meter_readings = await self._hass.async_add_executor_job(lambda: self._session.meter_readings(meter_id))
         _LOGGER.info(f"init meter readings for {NAME} - meter id: {meter_id}") 
         assert meter_readings is not None
         self._meter_readings[meter_id] = meter_readings.get("results")[0]
         return meter_readings.get("results")[0]
-
+                
     @Throttle(MIN_TIME_BETWEEN_UPDATES)
-    async def _update(self, meter_id):
-        if not(self._session):
-            self._session = ComponentSession()
-
-        if self._session:
-            await self._hass.async_add_executor_job(lambda: self._session.login(self._username, self._password))
-            meter_readings = await self._hass.async_add_executor_job(lambda: self._session.meter_readings(meter_id))
-            _LOGGER.debug(f"updated meter readings for {NAME} - meter id: {meter_id}") 
-            assert meter_readings is not None
-            self._meter_readings[meter_id] = meter_readings.get("results")[0]
-
-    async def update(self, meter_id):
-        await self._update(meter_id)
-        _LOGGER.debug(f"updated meter readings for {NAME} - meter id: {meter_id} - result: {self._meter_readings.get(meter_id)}") 
-        return self._meter_readings.get(meter_id)
+    async def _update(self):
+        await self._forced_update()
 
+    async def update(self):
+        await self._update()
+
+    def clear_session(self):
+        self._session : None
 
 class Component(Entity):
     def __init__(self, data, meter_details, meter_reading, hass):
@@ -138,7 +178,8 @@ def state(self):
         return self._meter_reading.get("value")
 
     async def async_update(self):
-        self._meter_reading = await self._data.update(self._meter_id )
+        await self._data.update()
+        self._meter_reading = self._data._meter_readings.get(self._meter_id)
 
 
     async def async_will_remove_from_hass(self):