gazpar2haws 0.2.0b1__py3-none-any.whl → 0.3.0__py3-none-any.whl

gazpar2haws/gazpar.py

@@ -1,12 +1,23 @@
 import logging
 import traceback
-from datetime import datetime, timedelta
-from typing import Any
+from datetime import date, datetime, timedelta
+from typing import Optional
 
 import pygazpar  # type: ignore
 import pytz
+from pygazpar.datasource import MeterReadings  # type: ignore
 
+from gazpar2haws.date_array import DateArray
 from gazpar2haws.haws import HomeAssistantWS, HomeAssistantWSException
+from gazpar2haws.model import (
+    ConsumptionQuantityArray,
+    Device,
+    PriceUnit,
+    Pricing,
+    QuantityUnit,
+    TimeUnit,
+)
+from gazpar2haws.pricer import Pricer
 
 Logger = logging.getLogger(__name__)
 
@@ -15,35 +26,51 @@ Logger = logging.getLogger(__name__)
 class Gazpar:
 
     # ----------------------------------
-    def __init__(self, config: dict[str, Any], homeassistant: HomeAssistantWS):
+    def __init__(
+        self,
+        device_config: Device,
+        pricing_config: Optional[Pricing],
+        homeassistant: HomeAssistantWS,
+    ):
 
         self._homeassistant = homeassistant
+        self._grdf_config = device_config
+        self._pricing_config = pricing_config
+
+        # GrDF configuration: name
+        self._name = device_config.name
+
+        # GrDF configuration: data source
+        self._data_source = device_config.data_source
+
+        # GrDF configuration: username
+        self._username = device_config.username
+
+        # GrDF configuration: password
+        self._password = device_config.password.get_secret_value() if device_config.password is not None else None
+
+        # GrDF configuration: pce_identifier
+        self._pce_identifier = (
+            device_config.pce_identifier.get_secret_value() if device_config.pce_identifier is not None else None
+        )
+
+        # GrDF configuration: tmp_dir
+        self._tmp_dir = device_config.tmp_dir
+
+        # GrDF configuration: last_days
+        self._last_days = device_config.last_days
 
-        # GrDF configuration
-        self._name = config.get("name")
-        self._data_source = config.get("data_source")
-        self._username = config.get("username")
-        self._password = config.get("password")
-        self._pce_identifier = str(config.get("pce_identifier"))
-        self._tmp_dir = config.get("tmp_dir")
-        self._last_days = int(str(config.get("last_days")))
-        self._timezone = str(config.get("timezone"))
-        self._reset = bool(config.get("reset"))
+        # GrDF configuration: timezone
+        self._timezone = device_config.timezone
+
+        # GrDF configuration: reset
+        self._reset = device_config.reset
 
         # As of date: YYYY-MM-DD
-        as_of_date = config.get("as_of_date")
-        if self._data_source is not None and str(self._data_source).lower() == "test":
-            self._as_of_date = (
-                datetime.now(tz=pytz.timezone(self._timezone))
-                if as_of_date is None
-                else datetime.strptime(as_of_date, "%Y-%m-%d")
-            )
-        else:
-            self._as_of_date = datetime.now(tz=pytz.timezone(self._timezone))
+        self._as_of_date = device_config.as_of_date
 
         # Set the timezone
-        timezone = pytz.timezone(self._timezone)
-        self._as_of_date = timezone.localize(self._as_of_date)
+        self._timezone = device_config.timezone
 
     # ----------------------------------
     def name(self):
@@ -51,42 +78,129 @@ class Gazpar:
 
     # ----------------------------------
     # Publish Gaspar data to Home Assistant WS
-    async def publish(self):
+    async def publish(self):  # pylint: disable=too-many-branches, too-many-statements
 
-        # Volume and energy sensor names.
+        # Volume, energy and cost sensor names.
         volume_sensor_name = f"sensor.{self._name}_volume"
         energy_sensor_name = f"sensor.{self._name}_energy"
+        cost_sensor_name = f"sensor.{self._name}_cost"
 
         # Eventually reset the sensor in Home Assistant
         if self._reset:
             try:
-                await self._homeassistant.clear_statistics(
-                    [volume_sensor_name, energy_sensor_name]
-                )
+                await self._homeassistant.clear_statistics([volume_sensor_name, energy_sensor_name])
             except Exception:
-                Logger.warning(
-                    f"Error while resetting the sensor in Home Assistant: {traceback.format_exc()}"
-                )
+                Logger.warning(f"Error while resetting the sensor in Home Assistant: {traceback.format_exc()}")
                 raise
 
-        # Publish volume sensor
-        await self._publish_entity(
-            volume_sensor_name, pygazpar.PropertyName.VOLUME.value, "m³"
+        last_date_and_value_by_sensor = dict[str, tuple[date, float]]()
+
+        last_date_and_value_by_sensor[volume_sensor_name] = await self.find_last_date_and_value(volume_sensor_name)
+        last_date_and_value_by_sensor[energy_sensor_name] = await self.find_last_date_and_value(energy_sensor_name)
+        last_date_and_value_by_sensor[cost_sensor_name] = await self.find_last_date_and_value(cost_sensor_name)
+
+        # Compute the start date as the minimum of the last dates plus one day
+        start_date = min(
+            min(v[0] for v in last_date_and_value_by_sensor.values()) + timedelta(days=1), self._as_of_date
         )
-        await self._publish_entity(
-            energy_sensor_name, pygazpar.PropertyName.ENERGY.value, "kWh"
+
+        # Get all start dates
+        energy_start_date = last_date_and_value_by_sensor[energy_sensor_name][0] + timedelta(days=1)
+        volume_start_date = last_date_and_value_by_sensor[volume_sensor_name][0] + timedelta(days=1)
+        cost_start_date = last_date_and_value_by_sensor[cost_sensor_name][0] + timedelta(days=1)
+
+        Logger.debug(f"Min start date for all sensors: {start_date}")
+        Logger.debug(f"Energy start date: {energy_start_date}")
+        Logger.debug(f"Volume start date: {volume_start_date}")
+        Logger.debug(f"Cost start date: {cost_start_date}")
+
+        # Fetch the data from GrDF and publish it to Home Assistant
+        daily_history = self.fetch_daily_gazpar_history(start_date, self._as_of_date)
+
+        # The end date is the last date of the daily history
+        if daily_history is None or len(daily_history) == 0:
+            end_date = start_date
+        else:
+            end_date = datetime.strptime(daily_history[-1][pygazpar.PropertyName.TIME_PERIOD.value], "%d/%m/%Y").date()
+
+        Logger.debug(f"End date: {end_date}")
+
+        # Extract the volume from the daily history
+        volume_array = self.extract_property_from_daily_gazpar_history(
+            daily_history,
+            pygazpar.PropertyName.VOLUME.value,
+            volume_start_date,
+            end_date,
+        )
+
+        # Extract the energy from the daily history
+        energy_array = self.extract_property_from_daily_gazpar_history(
+            daily_history,
+            pygazpar.PropertyName.ENERGY.value,
+            min(energy_start_date, cost_start_date),
+            end_date,
         )
 
+        # Publish the volume and energy to Home Assistant
+        if volume_array is not None:
+            await self.publish_date_array(
+                volume_sensor_name,
+                "m³",
+                volume_array,
+                last_date_and_value_by_sensor[volume_sensor_name][1],
+            )
+        else:
+            Logger.info("No volume data to publish")
+
+        if energy_array is not None and energy_start_date <= end_date:
+            await self.publish_date_array(
+                energy_sensor_name,
+                "kWh",
+                energy_array[energy_start_date : end_date + timedelta(days=1)],
+                last_date_and_value_by_sensor[energy_sensor_name][1],
+            )
+        else:
+            Logger.info("No energy data to publish")
+
+        if self._pricing_config is None:
+            Logger.info("No pricing configuration provided")
+            return
+
+        # Compute the cost from the energy
+        if energy_array is not None:
+            pricer = Pricer(self._pricing_config)
+
+            quantities = ConsumptionQuantityArray(
+                start_date=cost_start_date,
+                end_date=end_date,
+                value_unit=QuantityUnit.KWH,
+                base_unit=TimeUnit.DAY,
+                value_array=energy_array[cost_start_date : end_date + timedelta(days=1)],
+            )
+
+            cost_array = pricer.compute(quantities, PriceUnit.EURO)
+        else:
+            cost_array = None
+
+        # Publish the cost to Home Assistant
+        if cost_array is not None:
+            cost_initial_value = last_date_and_value_by_sensor[cost_sensor_name][1]
+            await self.publish_date_array(
+                cost_sensor_name,
+                cost_array.value_unit,
+                cost_array.value_array,
+                cost_initial_value,
+            )
+        else:
+            Logger.info("No cost data to publish")
+
     # ----------------------------------
-    # Publish a sensor to Home Assistant
-    async def _publish_entity(
-        self, entity_id: str, property_name: str, unit_of_measurement: str
-    ):
+    # Fetch daily Gazpar history.
+    def fetch_daily_gazpar_history(self, start_date: date, end_date: date) -> MeterReadings:
 
-        # Find last date, days and value of the entity.
-        last_date, last_days, last_value = await self._find_last_date_days_value(
-            entity_id
-        )
+        if start_date >= end_date:
+            Logger.info("No data to fetch")
+            return []
 
         # Instantiate the right data source.
         data_source = self._create_data_source()
@@ -95,42 +209,85 @@ class Gazpar:
         client = pygazpar.Client(data_source)
 
         try:
-            data = client.loadSince(
-                pceIdentifier=self._pce_identifier,
-                lastNDays=last_days,
+            history = client.load_date_range(
+                pce_identifier=self._pce_identifier,
+                start_date=start_date,
+                end_date=end_date,
                 frequencies=[pygazpar.Frequency.DAILY],
             )
+
+            # Filter the daily readings by keeping only dates between start_date and end_date
+            res = []
+            for reading in history[pygazpar.Frequency.DAILY.value]:
+                reading_date = datetime.strptime(reading[pygazpar.PropertyName.TIME_PERIOD.value], "%d/%m/%Y").date()
+                if start_date <= reading_date <= end_date:
+                    res.append(reading)
+
+            Logger.debug(f"Fetched {len(res)} daily readings from start date {start_date} to end date {end_date}")
         except Exception:  # pylint: disable=broad-except
-            Logger.warning(
-                f"Error while fetching data from GrDF: {traceback.format_exc()}"
-            )
-            data = {}
+            Logger.warning(f"Error while fetching data from GrDF: {traceback.format_exc()}")
+            res = MeterReadings()
 
-        # Timezone
-        timezone = pytz.timezone(self._timezone)
+        return res
 
-        # Compute and fill statistics.
-        daily = data.get(pygazpar.Frequency.DAILY.value)
-        statistics = []
-        total = last_value
-        for reading in daily:
+    # ----------------------------------
+    # Extract a given property from the daily Gazpar history and return a DateArray.
+    def extract_property_from_daily_gazpar_history(
+        self,
+        readings: MeterReadings,
+        property_name: str,
+        start_date: date,
+        end_date: date,
+    ) -> Optional[DateArray]:
+
+        # Fill the quantity array.
+        res: Optional[DateArray] = None
+
+        for reading in readings:
             # Parse date format DD/MM/YYYY into datetime.
-            date = datetime.strptime(
-                reading[pygazpar.PropertyName.TIME_PERIOD.value], "%d/%m/%Y"
-            )
+            reading_date = datetime.strptime(reading[pygazpar.PropertyName.TIME_PERIOD.value], "%d/%m/%Y").date()
 
-            # Set the timezone
-            date = timezone.localize(date)
+            # Skip all readings before the start date.
+            if reading_date < start_date:
+                # Logger.debug(f"Skip date: {reading_date} < {start_date}")
+                continue
 
-            # Skip all readings before the last statistic date.
-            if date <= last_date:
-                Logger.debug(f"Skip date: {date} <= {last_date}")
+            # Skip all readings after the end date.
+            if reading_date > end_date:
+                # Logger.debug(f"Skip date: {reading_date} > {end_date}")
                 continue
 
-            # Compute the total volume and energy
-            total += reading[property_name]
+            # Fill the quantity array.
+            if reading[property_name] is not None:
+                if res is None:
+                    res = DateArray(name=property_name, start_date=start_date, end_date=end_date)
+                res[reading_date] = reading[property_name]
+
+        return res
+
+    # ----------------------------------
+    # Push a date array to Home Assistant.
+    async def publish_date_array(
+        self,
+        entity_id: str,
+        unit_of_measurement: str,
+        date_array: DateArray,
+        initial_value: float,
+    ):
 
-            statistics.append({"start": date.isoformat(), "state": total, "sum": total})
+        # Compute the cumulative sum of the values.
+        total_array = date_array.cumsum() + initial_value
+
+        # Timezone
+        timezone = pytz.timezone(self._timezone)
+
+        # Fill the statistics.
+        statistics = []
+        for dt, total in total_array:
+            # Set the timezone
+            date_time = datetime.combine(dt, datetime.min.time())
+            date_time = timezone.localize(date_time)
+            statistics.append({"start": date_time.isoformat(), "state": total, "sum": total})
 
         # Publish statistics to Home Assistant
         try:
@@ -138,9 +295,7 @@ class Gazpar:
                 entity_id, "recorder", "gazpar2haws", unit_of_measurement, statistics
             )
         except Exception:
-            Logger.warning(
-                f"Error while importing statistics to Home Assistant: {traceback.format_exc()}"
-            )
+            Logger.warning(f"Error while importing statistics to Home Assistant: {traceback.format_exc()}")
             raise
 
     # ----------------------------------
@@ -158,36 +313,31 @@ class Gazpar:
                     tmpDirectory=self._tmp_dir,
                 )
 
-        return pygazpar.JsonWebDataSource(
-            username=self._username, password=self._password
-        )
+        return pygazpar.JsonWebDataSource(username=self._username, password=self._password)
 
     # ----------------------------------
-    # Find last date, days and value of the entity.
-    async def _find_last_date_days_value(
-        self, entity_id: str
-    ) -> tuple[datetime, int, float]:
+    # Find last date, value of the entity.
+    async def find_last_date_and_value(self, entity_id: str) -> tuple[date, float]:
 
         # Check the existence of the sensor in Home Assistant
         try:
-            exists_statistic_id = await self._homeassistant.exists_statistic_id(
-                entity_id, "sum"
-            )
+            exists_statistic_id = await self._homeassistant.exists_statistic_id(entity_id, "sum")
         except Exception:
             Logger.warning(
-                f"Error while checking the existence of the sensor in Home Assistant: {traceback.format_exc()}"
+                f"Error while checking the existence of the entity '{entity_id}' in Home Assistant: {traceback.format_exc()}"
             )
             raise
 
         if exists_statistic_id:
             # Get the last statistic from Home Assistant
             try:
-                last_statistic = await self._homeassistant.get_last_statistic(
-                    entity_id, self._as_of_date, self._last_days
-                )
+                as_of_date = datetime.combine(self._as_of_date, datetime.min.time())
+                as_of_date = pytz.timezone(self._timezone).localize(as_of_date)
+
+                last_statistic = await self._homeassistant.get_last_statistic(entity_id, as_of_date, self._last_days)
             except HomeAssistantWSException:
                 Logger.warning(
-                    f"Error while fetching last statistics from Home Assistant: {traceback.format_exc()}"
+                    f"Error while fetching last statistics of the entity '{entity_id}' from Home Assistant: {traceback.format_exc()}"
                 )
 
             if last_statistic:
@@ -195,35 +345,25 @@ class Gazpar:
                 last_date = datetime.fromtimestamp(
                     int(str(last_statistic.get("start"))) / 1000,
                     tz=pytz.timezone(self._timezone),
-                )
-
-                # Compute the number of days since the last statistics
-                last_days = (self._as_of_date - last_date).days
+                ).date()
 
                 # Get the last meter value
                 last_value = float(str(last_statistic.get("sum")))
 
-                Logger.debug(
-                    f"Last date: {last_date}, last days: {last_days}, last value: {last_value}"
-                )
+                Logger.debug(f"Entity '{entity_id}' => Last date: {last_date}, last value: {last_value}")
 
-                return last_date, last_days, last_value
+                return last_date, last_value
 
-            Logger.debug(f"No statistics found for the existing sensor {entity_id}.")
+            Logger.debug(f"Entity '{entity_id}' => No statistics found.")
         else:
-            Logger.debug(f"Sensor {entity_id} does not exist in Home Assistant.")
-
-        # If the sensor does not exist in Home Assistant, fetch the last days defined in the configuration
-        last_days = self._last_days
+            Logger.debug(f"Entity '{entity_id}' does not exist in Home Assistant.")
 
         # Compute the corresponding last_date
-        last_date = self._as_of_date - timedelta(days=last_days)
+        last_date = self._as_of_date - timedelta(days=self._last_days)
 
         # If no statistic, the last value is initialized to zero
         last_value = 0
 
-        Logger.debug(
-            f"Last date: {last_date}, last days: {last_days}, last value: {last_value}"
-        )
+        Logger.debug(f"Entity '{entity_id}' => Last date: {last_date}, last value: {last_value}")
 
-        return last_date, last_days, last_value
+        return last_date, last_value

gazpar2haws/haws.py

@@ -15,7 +15,7 @@ class HomeAssistantWSException(Exception):
 # ----------------------------------
 class HomeAssistantWS:
     # ----------------------------------
-    def __init__(self, host: str, port: str, endpoint: str, token: str):
+    def __init__(self, host: str, port: int, endpoint: str, token: str):
         self._host = host
         self._port = port
         self._endpoint = endpoint
@@ -92,9 +92,7 @@ class HomeAssistantWS:
             raise HomeAssistantWSException(f"Invalid response message: {response_data}")
 
         if not response_data.get("success"):
-            raise HomeAssistantWSException(
-                f"Request failed: {response_data.get('error')}"
-            )
+            raise HomeAssistantWSException(f"Request failed: {response_data.get('error')}")
 
         return response_data.get("result")
 
@@ -122,17 +120,13 @@ class HomeAssistantWS:
         return response
 
     # ----------------------------------
-    async def exists_statistic_id(
-        self, entity_id: str, statistic_type: str | None = None
-    ) -> bool:
+    async def exists_statistic_id(self, entity_id: str, statistic_type: str | None = None) -> bool:
 
         Logger.debug(f"Checking if {entity_id} exists...")
 
         statistic_ids = await self.list_statistic_ids(statistic_type)
 
-        entity_ids = [
-            statistic_id.get("statistic_id") for statistic_id in statistic_ids
-        ]
+        entity_ids = [statistic_id.get("statistic_id") for statistic_id in statistic_ids]
 
         exists_statistic = entity_id in entity_ids
 
@@ -141,13 +135,9 @@ class HomeAssistantWS:
         return exists_statistic
 
     # ----------------------------------
-    async def statistics_during_period(
-        self, entity_ids: list[str], start_time: datetime, end_time: datetime
-    ) -> dict:
+    async def statistics_during_period(self, entity_ids: list[str], start_time: datetime, end_time: datetime) -> dict:
 
-        Logger.debug(
-            f"Getting {entity_ids} statistics during period from {start_time} to {end_time}..."
-        )
+        Logger.debug(f"Getting {entity_ids} statistics during period from {start_time} to {end_time}...")
 
         # Subscribe to statistics
         statistics_message = {
@@ -166,16 +156,12 @@ class HomeAssistantWS:
                 f"Invalid statistics_during_period response type: got {type(response)} instead of dict"
             )
 
-        Logger.debug(
-            f"Received {entity_ids} statistics during period from {start_time} to {end_time}"
-        )
+        Logger.debug(f"Received {entity_ids} statistics during period from {start_time} to {end_time}")
 
         return response
 
     # ----------------------------------
-    async def get_last_statistic(
-        self, entity_id: str, as_of_date: datetime, depth_days: int
-    ) -> dict:
+    async def get_last_statistic(self, entity_id: str, as_of_date: datetime, depth_days: int) -> dict:
 
         Logger.debug(f"Getting last statistic for {entity_id}...")
 
@@ -201,9 +187,7 @@ class HomeAssistantWS:
         statistics: list[dict],
     ):
 
-        Logger.debug(
-            f"Importing {len(statistics)} statistics for {entity_id} from {source}..."
-        )
+        Logger.debug(f"Importing {len(statistics)} statistics for {entity_id} from {source}...")
 
         if len(statistics) == 0:
             Logger.debug("No statistics to import")
@@ -225,9 +209,7 @@ class HomeAssistantWS:
 
         await self.send_message(import_statistics_message)
 
-        Logger.debug(
-            f"Imported {len(statistics)} statistics for {entity_id} from {source}"
-        )
+        Logger.debug(f"Imported {len(statistics)} statistics for {entity_id} from {source}")
 
     # ----------------------------------
     async def clear_statistics(self, entity_ids: list[str]):