gazpar2haws 0.2.0a20__py3-none-any.whl → 0.2.1__py3-none-any.whl

gazpar2haws/__main__.py

@@ -1,91 +1,104 @@
-import asyncio
-import argparse
-import logging
-import traceback
-from gazpar2haws import config_utils
-from gazpar2haws import __version__
-from gazpar2haws.bridge import Bridge
-
-Logger = logging.getLogger(__name__)
-
-
-# ----------------------------------
-async def main():
-    """Main function"""
-    parser = argparse.ArgumentParser(prog="gazpar2haws", description="Gateway that reads data history from the GrDF (French gas provider) meter and send it to Home Assistant using WebSocket interface.")
-    parser.add_argument("-v", "--version",
-                        action="version",
-                        version="Gazpar2HAWS version")
-    parser.add_argument("-c", "--config",
-                        required=False,
-                        default="config/configuration.yaml",
-                        help="Path to the configuration file")
-    parser.add_argument("-s", "--secrets",
-                        required=False,
-                        default="config/secrets.yaml",
-                        help="Path to the secret file")
-
-    args = parser.parse_args()
-
-    try:
-        # Load configuration files
-        config = config_utils.ConfigLoader(args.config, args.secrets)
-        config.load_secrets()
-        config.load_config()
-
-        print(f"Gazpar2HAWS version: {__version__}")
-
-        # Set up logging
-        logging_file = config.get("logging.file")
-        logging_console = bool(config.get("logging.console"))
-        logging_level = config.get("logging.level")
-        logging_format = config.get("logging.format")
-
-        # Convert logging level to integer
-        if logging_level.upper() == "DEBUG":
-            level = logging.DEBUG
-        elif logging_level.upper() == "INFO":
-            level = logging.INFO
-        elif logging_level.upper() == "WARNING":
-            level = logging.WARNING
-        elif logging_level.upper() == "ERROR":
-            level = logging.ERROR
-        elif logging_level.upper() == "CRITICAL":
-            level = logging.CRITICAL
-        else:
-            level = logging.INFO
-
-        logging.basicConfig(filename=logging_file, level=level, format=logging_format)
-
-        if logging_console:
-            # Add a console handler manually
-            console_handler = logging.StreamHandler()
-            console_handler.setLevel(level)  # Set logging level for the console
-            console_handler.setFormatter(logging.Formatter(logging_format))  # Customize console format
-
-            # Get the root logger and add the console handler
-            logging.getLogger().addHandler(console_handler)
-
-        Logger.info(f"Starting Gazpar2HAWS version {__version__}")
-
-        # Log configuration
-        Logger.info(f"Configuration:\n{config.dumps()}")
-
-        # Start the bridge
-        bridge = Bridge(config)
-        await bridge.run()
-
-        Logger.info("Gazpar2HAWS stopped.")
-
-        return 0
-
-    except BaseException:
-        errorMessage = f"An error occured while running Gazpar2HAWS: {traceback.format_exc()}"
-        Logger.error(errorMessage)
-        print(errorMessage)
-        return 1
-
-
-# ----------------------------------
-if __name__ == '__main__':
-    asyncio.run(main())
+import argparse
+import asyncio
+import logging
+import traceback
+
+from gazpar2haws import __version__, config_utils
+from gazpar2haws.bridge import Bridge
+
+Logger = logging.getLogger(__name__)
+
+
+# ----------------------------------
+async def main():
+    """Main function"""
+    parser = argparse.ArgumentParser(
+        prog="gazpar2haws",
+        description="Gateway that reads data history from the GrDF (French gas provider) meter and send it to Home Assistant using WebSocket interface.",
+    )
+    parser.add_argument(
+        "-v", "--version", action="version", version="Gazpar2HAWS version"
+    )
+    parser.add_argument(
+        "-c",
+        "--config",
+        required=False,
+        default="config/configuration.yaml",
+        help="Path to the configuration file",
+    )
+    parser.add_argument(
+        "-s",
+        "--secrets",
+        required=False,
+        default="config/secrets.yaml",
+        help="Path to the secret file",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        # Load configuration files
+        config = config_utils.ConfigLoader(args.config, args.secrets)
+        config.load_secrets()
+        config.load_config()
+
+        print(f"Gazpar2HAWS version: {__version__}")
+
+        # Set up logging
+        logging_file = config.get("logging.file")
+        logging_console = bool(config.get("logging.console"))
+        logging_level = config.get("logging.level")
+        logging_format = config.get("logging.format")
+
+        # Convert logging level to integer
+        if logging_level.upper() == "DEBUG":
+            level = logging.DEBUG
+        elif logging_level.upper() == "INFO":
+            level = logging.INFO
+        elif logging_level.upper() == "WARNING":
+            level = logging.WARNING
+        elif logging_level.upper() == "ERROR":
+            level = logging.ERROR
+        elif logging_level.upper() == "CRITICAL":
+            level = logging.CRITICAL
+        else:
+            level = logging.INFO
+
+        logging.basicConfig(filename=logging_file, level=level, format=logging_format)
+
+        if logging_console:
+            # Add a console handler manually
+            console_handler = logging.StreamHandler()
+            console_handler.setLevel(level)  # Set logging level for the console
+            console_handler.setFormatter(
+                logging.Formatter(logging_format)
+            )  # Customize console format
+
+            # Get the root logger and add the console handler
+            logging.getLogger().addHandler(console_handler)
+
+        Logger.info(f"Starting Gazpar2HAWS version {__version__}")
+
+        # Log configuration
+        Logger.info(f"Configuration:\n{config.dumps()}")
+
+        # Start the bridge
+        bridge = Bridge(config)
+        await bridge.run()
+
+        Logger.info("Gazpar2HAWS stopped.")
+
+        return 0
+
+    except Exception:  # pylint: disable=broad-except
+        errorMessage = (
+            f"An error occured while running Gazpar2HAWS: {traceback.format_exc()}"
+        )
+        Logger.error(errorMessage)
+        print(errorMessage)
+        return 1
+
+
+# ----------------------------------
+if __name__ == "__main__":
+    asyncio.run(main())

gazpar2haws/bridge.py

@@ -1,6 +1,7 @@
+import asyncio
 import logging
 import signal
-import asyncio
+
 from gazpar2haws import config_utils
 from gazpar2haws.gazpar import Gazpar
 from gazpar2haws.haws import HomeAssistantWS
@@ -15,12 +16,30 @@ class Bridge:
     def __init__(self, config: config_utils.ConfigLoader):
 
         # GrDF scan interval (in seconds)
+        if config.get("grdf.scan_interval") is None:
+            raise ValueError("Configuration parameter 'grdf.scan_interval' is missing")
         self._grdf_scan_interval = int(config.get("grdf.scan_interval"))
 
-        # Home Assistant configuration
+        # Home Assistant configuration: host
+        if config.get("homeassistant.host") is None:
+            raise ValueError("Configuration parameter 'homeassistant.host' is missing")
         ha_host = config.get("homeassistant.host")
+
+        # Home Assistant configuration: port
+        if config.get("homeassistant.port") is None:
+            raise ValueError("Configuration parameter 'homeassistant.port' is missing")
         ha_port = config.get("homeassistant.port")
-        ha_endpoint = config.get("homeassistant.endpoint")
+
+        # Home Assistant configuration: endpoint
+        ha_endpoint = (
+            config.get("homeassistant.endpoint")
+            if config.get("homeassistant.endpoint")
+            else "/api/websocket"
+        )
+
+        # Home Assistant configuration: token
+        if config.get("homeassistant.token") is None:
+            raise ValueError("Configuration parameter 'homeassistant.token' is missing")
         ha_token = config.get("homeassistant.token")
 
         # Initialize Home Assistant
@@ -28,6 +47,9 @@ class Bridge:
 
         # Initialize Gazpar
         self._gazpar = []
+
+        if config.get("grdf.devices") is None:
+            raise ValueError("Configuration parameter 'grdf.devices' is missing")
         for grdf_device_config in config.get("grdf.devices"):
             self._gazpar.append(Gazpar(grdf_device_config, self._homeassistant))
 
@@ -40,7 +62,7 @@ class Bridge:
 
     # ----------------------------------
     # Graceful shutdown function
-    def handle_signal(self, signum, frame):
+    def handle_signal(self, signum, _):
         print(f"Signal {signum} received. Shutting down gracefully...")
         Logger.info(f"Signal {signum} received. Shutting down gracefully...")
         self._running = False
@@ -63,7 +85,9 @@ class Bridge:
                 for gazpar in self._gazpar:
                     Logger.info(f"Publishing data for device '{gazpar.name()}'...")
                     await gazpar.publish()
-                    Logger.info(f"Device '{gazpar.name()}' data published to Home Assistant WS.")
+                    Logger.info(
+                        f"Device '{gazpar.name()}' data published to Home Assistant WS."
+                    )
 
                 Logger.info("Gazpar data published to Home Assistant WS.")
 
@@ -71,7 +95,9 @@ class Bridge:
                 await self._homeassistant.disconnect()
 
                 # Wait before next scan
-                Logger.info(f"Waiting {self._grdf_scan_interval} minutes before next scan...")
+                Logger.info(
+                    f"Waiting {self._grdf_scan_interval} minutes before next scan..."
+                )
 
                 # Check if the scan interval is 0 and leave the loop.
                 if self._grdf_scan_interval == 0:

gazpar2haws/config_utils.py

@@ -1,56 +1,61 @@
-import yaml
-import os
-
-
-class ConfigLoader:
-    def __init__(self, config_file="config.yaml", secrets_file="secrets.yaml"):
-        self.config_file = config_file
-        self.secrets_file = secrets_file
-        self.config = {}
-        self.secrets = {}
-
-    def load_secrets(self):
-        """Load the secrets file."""
-        if os.path.exists(self.secrets_file):
-            with open(self.secrets_file, 'r') as file:
-                self.secrets = yaml.safe_load(file)
-        else:
-            raise FileNotFoundError(f"Secrets file '{self.secrets_file}' not found.")
-
-    def load_config(self):
-        """Load the main configuration file and resolve secrets."""
-        if os.path.exists(self.config_file):
-            with open(self.config_file, 'r', encoding='utf-8') as file:
-                self.raw_config = yaml.safe_load(file)
-            self.config = self._resolve_secrets(self.raw_config)
-        else:
-            raise FileNotFoundError(f"Configuration file '{self.config_file}' not found.")
-
-    def _resolve_secrets(self, data):
-        """Recursively resolve `!secret` keys in the configuration."""
-        if isinstance(data, dict):
-            return {key: self._resolve_secrets(value) for key, value in data.items()}
-        elif isinstance(data, list):
-            return [self._resolve_secrets(item) for item in data]
-        elif isinstance(data, str) and data.startswith("!secret"):
-            secret_key = data.split(" ", 1)[1]
-            if secret_key in self.secrets:
-                return self.secrets[secret_key]
-            else:
-                raise KeyError(f"Secret key '{secret_key}' not found in secrets file.")
-        else:
-            return data
-
-    def get(self, key, default=None):
-        """Get a configuration value."""
-        keys = key.split(".")
-        value = self.config
-        try:
-            for k in keys:
-                value = value[k]
-            return value
-        except (KeyError, TypeError):
-            return default
-
-    def dumps(self) -> str:
-        return yaml.dump(self.raw_config)
+import os
+from typing import Any
+
+import yaml
+
+
+class ConfigLoader:
+    def __init__(self, config_file: str, secrets_file: str):
+        self.config_file = config_file
+        self.secrets_file = secrets_file
+        self.config = dict[str, Any]()
+        self.secrets = dict[str, Any]()
+        self.raw_config = None
+
+    def load_secrets(self):
+        """Load the secrets file."""
+        if self.secrets_file is None:
+            return
+        if os.path.exists(self.secrets_file):
+            with open(self.secrets_file, "r", encoding="utf-8") as file:
+                self.secrets = yaml.safe_load(file)
+        else:
+            raise FileNotFoundError(f"Secrets file '{self.secrets_file}' not found.")
+
+    def load_config(self):
+        """Load the main configuration file and resolve secrets."""
+        if os.path.exists(self.config_file):
+            with open(self.config_file, "r", encoding="utf-8") as file:
+                self.raw_config = yaml.safe_load(file)
+            self.config = self._resolve_secrets(self.raw_config)
+        else:
+            raise FileNotFoundError(
+                f"Configuration file '{self.config_file}' not found."
+            )
+
+    def _resolve_secrets(self, data):
+        """Recursively resolve `!secret` keys in the configuration."""
+        if isinstance(data, dict):
+            return {key: self._resolve_secrets(value) for key, value in data.items()}
+        if isinstance(data, list):
+            return [self._resolve_secrets(item) for item in data]
+        if isinstance(data, str) and data.startswith("!secret"):
+            secret_key = data.split(" ", 1)[1]
+            if secret_key in self.secrets:
+                return self.secrets[secret_key]
+            raise KeyError(f"Secret key '{secret_key}' not found in secrets file.")
+        return data
+
+    def get(self, key, default=None):
+        """Get a configuration value."""
+        keys = key.split(".")
+        value = self.config
+        try:
+            for k in keys:
+                value = value[k]
+            return value
+        except (KeyError, TypeError):
+            return default
+
+    def dumps(self) -> str:
+        return yaml.dump(self.raw_config)

gazpar2haws/gazpar.py

@@ -1,139 +1,280 @@
-import pygazpar
-import traceback
-import logging
-import pytz
-from typing import Any
-from datetime import datetime, timedelta
-from gazpar2haws.haws import HomeAssistantWS
-
-Logger = logging.getLogger(__name__)
-
-
-# ----------------------------------
-class Gazpar:
-
-    # ----------------------------------
-    def __init__(self, config: dict[str, Any], homeassistant: HomeAssistantWS):
-
-        self._homeassistant = homeassistant
-
-        # GrDF configuration
-        self._name = config.get("name")
-        self._username = config.get("username")
-        self._password = config.get("password")
-        self._pce_identifier = str(config.get("pce_identifier"))
-        self._last_days = int(config.get("last_days"))
-        self._timezone = config.get("timezone")
-        self._reset = bool(config.get("reset"))
-
-    # ----------------------------------
-    def name(self):
-        return self._name
-
-    # ----------------------------------
-    # Publish Gaspar data to Home Assistant WS
-    async def publish(self):
-
-        # Volume and energy sensor names.
-        volume_sensor_name = f"sensor.{self._name}_volume"
-        energy_sensor_name = f"sensor.{self._name}_energy"
-
-        # Eventually reset the sensor in Home Assistant
-        if self._reset:
-            try:
-                await self._homeassistant.clear_statistics([volume_sensor_name, energy_sensor_name])
-            except Exception:
-                errorMessage = f"Error while resetting the sensor in Home Assistant: {traceback.format_exc()}"
-                Logger.warning(errorMessage)
-                raise Exception(errorMessage)
-
-        # Publish volume sensor
-        await self._publish_entity(volume_sensor_name, pygazpar.PropertyName.VOLUME.value, "m³")
-        await self._publish_entity(energy_sensor_name, pygazpar.PropertyName.ENERGY.value, "kWh")
-
-    # ----------------------------------
-    # Publish a sensor to Home Assistant
-    async def _publish_entity(self, entity_id: str, property_name: str, unit_of_measurement: str):
-
-        # Check the existence of the sensor in Home Assistant
-        try:
-            exists_statistic_id = await self._homeassistant.exists_statistic_id(entity_id, "sum")
-        except Exception:
-            errorMessage = f"Error while checking the existence of the sensor in Home Assistant: {traceback.format_exc()}"
-            Logger.warning(errorMessage)
-            raise Exception(errorMessage)
-
-        if exists_statistic_id:
-            # Get the last statistic from Home Assistant
-            try:
-                last_statistic = await self._homeassistant.get_last_statistic(entity_id)
-            except Exception:
-                errorMessage = f"Error while fetching last statistics from Home Assistant: {traceback.format_exc()}"
-                Logger.warning(errorMessage)
-                raise Exception(errorMessage)
-
-            # Extract the end date of the last statistics from the unix timestamp
-            last_date = datetime.fromtimestamp(last_statistic.get("start") / 1000, tz=pytz.timezone(self._timezone))
-
-            # Compute the number of days since the last statistics
-            last_days = (datetime.now(tz=pytz.timezone(self._timezone)) - last_date).days
-
-            # Get the last meter value
-            last_value = last_statistic.get("sum")
-        else:
-            # If the sensor does not exist in Home Assistant, fetch the last days defined in the configuration
-            last_days = self._last_days
-
-            # Compute the corresponding last_date
-            last_date = datetime.now(tz=pytz.timezone(self._timezone)) - timedelta(days=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}")
-
-        # Initialize PyGazpar client
-        client = pygazpar.Client(pygazpar.JsonWebDataSource(username=self._username, password=self._password))
-
-        try:
-            data = client.loadSince(pceIdentifier=self._pce_identifier, lastNDays=last_days, frequencies=[pygazpar.Frequency.DAILY])
-        except Exception:
-            errorMessage = f"Error while fetching data from GrDF: {traceback.format_exc()}"
-            Logger.warning(errorMessage)
-            data = {}
-
-        # Timezone
-        timezone = pytz.timezone(self._timezone)
-
-        # Compute and fill statistics.
-        daily = data.get(pygazpar.Frequency.DAILY.value)
-        statistics = []
-        total = last_value
-        for reading in daily:
-            # Parse date format DD/MM/YYYY into datetime.
-            date = datetime.strptime(reading[pygazpar.PropertyName.TIME_PERIOD.value], "%d/%m/%Y")
-
-            # Set the timezone
-            date = timezone.localize(date)
-
-            # Skip all readings before the last statistic date.
-            if date <= last_date:
-                Logger.debug(f"Skip date: {date} <= {last_date}")
-                continue
-
-            # Compute the total volume and energy
-            total += reading[property_name]
-
-            statistics.append({
-                "start": date.isoformat(),
-                "state": total,
-                "sum": total
-            })
-
-        # Publish statistics to Home Assistant
-        try:
-            await self._homeassistant.import_statistics(entity_id, "recorder", "gazpar2haws", unit_of_measurement, statistics)
-        except Exception:
-            errorMessage = f"Error while importing statistics to Home Assistant: {traceback.format_exc()}"
-            Logger.warning(errorMessage)
-            raise Exception(errorMessage)
+import logging
+import traceback
+from datetime import datetime, timedelta
+from typing import Any
+
+import pygazpar  # type: ignore
+import pytz
+
+from gazpar2haws.haws import HomeAssistantWS, HomeAssistantWSException
+
+Logger = logging.getLogger(__name__)
+
+
+# ----------------------------------
+class Gazpar:
+
+    # ----------------------------------
+    def __init__(self, config: dict[str, Any], homeassistant: HomeAssistantWS):
+
+        self._homeassistant = homeassistant
+
+        # GrDF configuration: name
+        if config.get("name") is None:
+            raise ValueError("Configuration parameter 'grdf.devices[].name' is missing")
+        self._name = config.get("name")
+
+        # GrDF configuration: data source
+        self._data_source = (
+            config.get("data_source") if config.get("data_source") else "json"
+        )
+
+        # GrDF configuration: username
+        if self._data_source != "test" and config.get("username") is None:
+            raise ValueError(
+                "Configuration parameter 'grdf.devices[].username' is missing"
+            )
+        self._username = config.get("username")
+
+        # GrDF configuration: password
+        if self._data_source != "test" and config.get("password") is None:
+            raise ValueError(
+                "Configuration parameter 'grdf.devices[].password' is missing"
+            )
+        self._password = config.get("password")
+
+        # GrDF configuration: pce_identifier
+        if self._data_source != "test" and config.get("pce_identifier") is None:
+            raise ValueError(
+                "Configuration parameter 'grdf.devices[].pce_identifier' is missing"
+            )
+        self._pce_identifier = str(config.get("pce_identifier"))
+
+        # GrDF configuration: tmp_dir
+        self._tmp_dir = config.get("tmp_dir") if config.get("tmp_dir") else "/tmp"
+
+        # GrDF configuration: last_days
+        if config.get("last_days") is None:
+            raise ValueError(
+                "Configuration parameter 'grdf.devices[].last_days' is missing"
+            )
+        self._last_days = int(str(config.get("last_days")))
+
+        # GrDF configuration: timezone
+        if config.get("timezone") is None:
+            raise ValueError(
+                "Configuration parameter 'grdf.devices[].timezone' is missing"
+            )
+        self._timezone = str(config.get("timezone"))
+
+        # GrDF configuration: reset
+        if config.get("reset") is None:
+            raise ValueError(
+                "Configuration parameter 'grdf.devices[].reset' is missing"
+            )
+        self._reset = bool(config.get("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))
+
+        # Set the timezone
+        timezone = pytz.timezone(self._timezone)
+        if self._as_of_date.tzinfo is None:
+            self._as_of_date = timezone.localize(self._as_of_date)
+
+    # ----------------------------------
+    def name(self):
+        return self._name
+
+    # ----------------------------------
+    # Publish Gaspar data to Home Assistant WS
+    async def publish(self):
+
+        # Volume and energy sensor names.
+        volume_sensor_name = f"sensor.{self._name}_volume"
+        energy_sensor_name = f"sensor.{self._name}_energy"
+
+        # Eventually reset the sensor in Home Assistant
+        if self._reset:
+            try:
+                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()}"
+                )
+                raise
+
+        # Publish volume sensor
+        await self._publish_entity(
+            volume_sensor_name, pygazpar.PropertyName.VOLUME.value, "m³"
+        )
+        await self._publish_entity(
+            energy_sensor_name, pygazpar.PropertyName.ENERGY.value, "kWh"
+        )
+
+    # ----------------------------------
+    # Publish a sensor to Home Assistant
+    async def _publish_entity(
+        self, entity_id: str, property_name: str, unit_of_measurement: str
+    ):
+
+        # Find last date, days and value of the entity.
+        last_date, last_days, last_value = await self._find_last_date_days_value(
+            entity_id
+        )
+
+        # Instantiate the right data source.
+        data_source = self._create_data_source()
+
+        # Initialize PyGazpar client
+        client = pygazpar.Client(data_source)
+
+        try:
+            data = client.loadSince(
+                pceIdentifier=self._pce_identifier,
+                lastNDays=last_days,
+                frequencies=[pygazpar.Frequency.DAILY],
+            )
+        except Exception:  # pylint: disable=broad-except
+            Logger.warning(
+                f"Error while fetching data from GrDF: {traceback.format_exc()}"
+            )
+            data = {}
+
+        # Timezone
+        timezone = pytz.timezone(self._timezone)
+
+        # Compute and fill statistics.
+        daily = data.get(pygazpar.Frequency.DAILY.value)
+        statistics = []
+        total = last_value
+        for reading in daily:
+            # Parse date format DD/MM/YYYY into datetime.
+            date = datetime.strptime(
+                reading[pygazpar.PropertyName.TIME_PERIOD.value], "%d/%m/%Y"
+            )
+
+            # Set the timezone
+            date = timezone.localize(date)
+
+            # Skip all readings before the last statistic date.
+            if date <= last_date:
+                Logger.debug(f"Skip date: {date} <= {last_date}")
+                continue
+
+            # Compute the total volume and energy
+            if reading[property_name] is not None:
+                total += reading[property_name]
+            else:
+                Logger.warning(
+                    f"Missing property {property_name} for date {date}. Skipping..."
+                )
+                continue
+
+            statistics.append({"start": date.isoformat(), "state": total, "sum": total})
+
+        # Publish statistics to Home Assistant
+        try:
+            await self._homeassistant.import_statistics(
+                entity_id, "recorder", "gazpar2haws", unit_of_measurement, statistics
+            )
+        except Exception:
+            Logger.warning(
+                f"Error while importing statistics to Home Assistant: {traceback.format_exc()}"
+            )
+            raise
+
+    # ----------------------------------
+    # Create the data source.
+    def _create_data_source(self) -> pygazpar.datasource.IDataSource:
+
+        if self._data_source is not None:
+            if str(self._data_source).lower() == "test":
+                return pygazpar.TestDataSource()
+
+            if str(self._data_source).lower() == "excel":
+                return pygazpar.ExcelWebDataSource(
+                    username=self._username,
+                    password=self._password,
+                    tmpDirectory=self._tmp_dir,
+                )
+
+        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]:
+
+        # Check the existence of the sensor in Home Assistant
+        try:
+            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()}"
+            )
+            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
+                )
+            except HomeAssistantWSException:
+                Logger.warning(
+                    f"Error while fetching last statistics from Home Assistant: {traceback.format_exc()}"
+                )
+
+            if last_statistic:
+                # Extract the end date of the last statistics from the unix timestamp
+                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
+
+                # 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}"
+                )
+
+                return last_date, last_days, last_value
+
+            Logger.debug(f"No statistics found for the existing sensor {entity_id}.")
+        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
+
+        # Compute the corresponding last_date
+        last_date = self._as_of_date - timedelta(days=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}"
+        )
+
+        return last_date, last_days, last_value

gazpar2haws/haws.py

@@ -1,13 +1,20 @@
-import websockets
 import json
-from datetime import datetime, timedelta
 import logging
+from datetime import datetime, timedelta
+
+import websockets
 
 Logger = logging.getLogger(__name__)
 
 
+# ----------------------------------
+class HomeAssistantWSException(Exception):
+    pass
+
+
 # ----------------------------------
 class HomeAssistantWS:
+    # ----------------------------------
     def __init__(self, host: str, port: str, endpoint: str, token: str):
         self._host = host
         self._port = port
@@ -24,7 +31,9 @@ class HomeAssistantWS:
         ws_url = f"ws://{self._host}:{self._port}{self._endpoint}"
 
         # Connect to the websocket
-        self._websocket = await websockets.connect(ws_url, additional_headers={"Authorization": f"Bearer {self._token}"})
+        self._websocket = await websockets.connect(
+            ws_url, additional_headers={"Authorization": f"Bearer {self._token}"}
+        )
 
         # When a client connects to the server, the server sends out auth_required.
         connect_response = await self._websocket.recv()
@@ -33,7 +42,7 @@ class HomeAssistantWS:
         if connect_response_data.get("type") != "auth_required":
             message = f"Authentication failed: auth_required not received {connect_response_data.get('messsage')}"
             Logger.warning(message)
-            raise Exception(message)
+            raise HomeAssistantWSException(message)
 
         # The first message from the client should be an auth message. You can authorize with an access token.
         auth_message = {"type": "auth", "access_token": self._token}
@@ -46,7 +55,7 @@ class HomeAssistantWS:
         if auth_response_data.get("type") == "auth_invalid":
             message = f"Authentication failed: {auth_response_data.get('messsage')}"
             Logger.warning(message)
-            raise Exception(message)
+            raise HomeAssistantWSException(message)
 
         Logger.debug("Connected to Home Assistant")
 
@@ -60,10 +69,13 @@ class HomeAssistantWS:
         Logger.debug("Disconnected from Home Assistant")
 
     # ----------------------------------
-    async def send_message(self, message: dict) -> dict:
+    async def send_message(self, message: dict) -> dict | list[dict]:
 
         Logger.debug("Sending a message...")
 
+        if self._websocket is None:
+            raise HomeAssistantWSException("Not connected to Home Assistant")
+
         message["id"] = self._message_id
 
         self._message_id += 1
@@ -77,40 +89,50 @@ class HomeAssistantWS:
         Logger.debug("Received response")
 
         if response_data.get("type") != "result":
-            raise Exception(f"Invalid response message: {response_data}")
+            raise HomeAssistantWSException(f"Invalid response message: {response_data}")
 
         if not response_data.get("success"):
-            raise Exception(f"Request failed: {response_data.get('error')}")
+            raise HomeAssistantWSException(
+                f"Request failed: {response_data.get('error')}"
+            )
 
         return response_data.get("result")
 
     # ----------------------------------
-    async def list_statistic_ids(self, statistic_type: str = None) -> list[str]:
+    async def list_statistic_ids(self, statistic_type: str | None = None) -> list[dict]:
 
         Logger.debug("Listing statistics IDs...")
 
         # List statistics IDs message
-        list_statistic_ids_message = {
-            "type": "recorder/list_statistic_ids"
-        }
+        list_statistic_ids_message = {"type": "recorder/list_statistic_ids"}
 
         if statistic_type is not None:
             list_statistic_ids_message["statistic_type"] = statistic_type
 
         response = await self.send_message(list_statistic_ids_message)
 
+        # Check response instance type
+        if not isinstance(response, list):
+            raise HomeAssistantWSException(
+                f"Invalid list_statistic_ids response type: got {type(response)} instead of list[dict]"
+            )
+
         Logger.debug(f"Listed statistics IDs: {len(response)} ids")
 
         return response
 
     # ----------------------------------
-    async def exists_statistic_id(self, entity_id: str, statistic_type: str = 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
 
@@ -119,9 +141,13 @@ 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 = {
@@ -129,30 +155,55 @@ class HomeAssistantWS:
             "start_time": start_time.isoformat(),
             "end_time": end_time.isoformat(),
             "statistic_ids": entity_ids,
-            "period": "day"
+            "period": "day",
         }
 
         response = await self.send_message(statistics_message)
 
-        Logger.debug(f"Received {entity_ids} statistics during period from {start_time} to {end_time}")
+        # Check response instance type
+        if not isinstance(response, dict):
+            raise HomeAssistantWSException(
+                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}"
+        )
 
         return response
 
     # ----------------------------------
-    async def get_last_statistic(self, entity_id: str) -> 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}...")
 
-        statistics = await self.statistics_during_period([entity_id], datetime.now() - timedelta(days=30), datetime.now())
+        statistics = await self.statistics_during_period(
+            [entity_id], as_of_date - timedelta(days=depth_days), as_of_date
+        )
+
+        if not statistics:
+            Logger.warning(f"No statistics found for {entity_id}.")
+            return {}
 
         Logger.debug(f"Last statistic for {entity_id}: {statistics[entity_id][-1]}")
 
         return statistics[entity_id][-1]
 
     # ----------------------------------
-    async def import_statistics(self, entity_id: str, source: str, name: str, unit_of_measurement: str, statistics: list[dict]):
-
-        Logger.debug(f"Importing {len(statistics)} statistics for {entity_id} from {source}...")
+    async def import_statistics(
+        self,
+        entity_id: str,
+        source: str,
+        name: str,
+        unit_of_measurement: str,
+        statistics: list[dict],
+    ):
+
+        Logger.debug(
+            f"Importing {len(statistics)} statistics for {entity_id} from {source}..."
+        )
 
         if len(statistics) == 0:
             Logger.debug("No statistics to import")
@@ -162,19 +213,21 @@ class HomeAssistantWS:
         import_statistics_message = {
             "type": "recorder/import_statistics",
             "metadata": {
-                    "has_mean": False,
-                    "has_sum": True,
-                    "statistic_id": entity_id,
-                    "source": source,
-                    "name": name,
-                    "unit_of_measurement": unit_of_measurement,
+                "has_mean": False,
+                "has_sum": True,
+                "statistic_id": entity_id,
+                "source": source,
+                "name": name,
+                "unit_of_measurement": unit_of_measurement,
             },
-            "stats": statistics
+            "stats": statistics,
         }
 
         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]):
@@ -184,7 +237,7 @@ class HomeAssistantWS:
         # Clear statistics message
         clear_statistics_message = {
             "type": "recorder/clear_statistics",
-            "statistic_ids": entity_ids
+            "statistic_ids": entity_ids,
         }
 
         await self.send_message(clear_statistics_message)

gazpar2haws/version.py

@@ -1,3 +1,3 @@
 import importlib.metadata
 
-__version__ = importlib.metadata.version('gazpar2haws')
+__version__ = importlib.metadata.version("gazpar2haws")

{gazpar2haws-0.2.0a20.dist-info → gazpar2haws-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gazpar2haws
-Version: 0.2.0a20
+Version: 0.2.1
 Summary: Gazpar2HAWS is a gateway that reads data history from the GrDF (French gas provider) meter and send it to Home Assistant using WebSocket interface
 License: MIT License
          
@@ -52,7 +52,7 @@ Gazpar2HAWS can be installed in many ways.
 
 ### 1. Home Assistant Add-on
 
-In the **Add-on store**, click **⋮ → Repositories**, fill in **`https://github.com/ssenart/gazpar2haws`** and click **Add → Close** or click the **Add repository** button below, click **Add → Close** (You might need to enter the **internal IP address** of your Home Assistant instance first).  
+In the **Add-on store**, click **⋮ → Repositories**, fill in **`https://github.com/ssenart/gazpar2haws`** and click **Add → Close** or click the **Add repository** button below, click **Add → Close** (You might need to enter the **internal IP address** of your Home Assistant instance first).
 
 [![Open your Home Assistant instance and show the add add-on repository dialog with a specific repository URL pre-filled.](https://my.home-assistant.io/badges/supervisor_add_addon_repository.svg)](https://my.home-assistant.io/redirect/supervisor_add_addon_repository/?repository_url=https%3A%2F%2Fgithub.com%2Fssenart%2Fgazpar2haws)
 
@@ -67,11 +67,11 @@ The following steps permits to run a container from an existing image available
 ```yaml
 services:
   gazpar2haws:
-    image: ssenart/gazpar2haws:latest  
+    image: ssenart/gazpar2haws:latest
     container_name: gazpar2haws
     restart: unless-stopped
     network_mode: bridge
-    user: "1000:1000"    
+    user: "1000:1000"
     volumes:
       - ./gazpar2haws/config:/app/config
       - ./gazpar2haws/log:/app/log
@@ -86,6 +86,7 @@ services:
 Edit the environment variable section according to your setup.
 
 2. Run the container:
+
 ```sh
 $ docker compose up -d
 ```
@@ -112,27 +113,33 @@ $ pip install gazpar2haws
 The following steps permit to build the Docker image based on the local source files.
 
 1. Clone the repo locally:
+
 ```sh
 $ cd /path/to/my_install_folder/
 
 $ git clone https://github.com/ssenart/gazpar2haws.git
 ```
+
 2. Edit the docker-compose.yaml file by setting the environment variables corresponding to your GrDF account and Home Assistant setup:
 
 ```yaml
-    environment:
-      - GRDF_USERNAME=<GrDF account username>
-      - GRDF_PASSWORD=<GrDF account password>
-      - GRDF_PCE_IDENTIFIER=<GrDF PCE meter identifier>
-      - HOMEASSISTANT_HOST=<Home Assistant instance host name>
-      - HOMEASSISTANT_PORT=<Home Assistant instance port number>
-      - HOMEASSISTANT_TOKEN=<Home Assistant access token>
+environment:
+  - GRDF_USERNAME=<GrDF account username>
+  - GRDF_PASSWORD=<GrDF account password>
+  - GRDF_PCE_IDENTIFIER=<GrDF PCE meter identifier>
+  - HOMEASSISTANT_HOST=<Home Assistant instance host name>
+  - HOMEASSISTANT_PORT=<Home Assistant instance port number>
+  - HOMEASSISTANT_TOKEN=<Home Assistant access token>
 ```
+
 3. Build the image:
+
 ```sh
 $ docker compose -f docker/docker-compose.yaml build
 ```
+
 4. Run the container:
+
 ```sh
 $ docker compose -f docker/docker-compose.yaml up -d
 ```
@@ -171,18 +178,18 @@ logging:
   file: log/gazpar2haws.log
   console: true
   level: debug
-  format: '%(asctime)s %(levelname)s [%(name)s] %(message)s'
+  format: "%(asctime)s %(levelname)s [%(name)s] %(message)s"
 
 grdf:
   scan_interval: 0 # Number of minutes between each data retrieval (0 means no scan: a single data retrieval at startup, then stops).
   devices:
-  - name: gazpar2haws # Name of the device in home assistant. It will be used as the entity_ids: sensor.${name}_volume and sensor.${name}_energy.
-    username: "!secret grdf.username"
-    password: "!secret grdf.password"
-    pce_identifier: "!secret grdf.pce_identifier"
-    timezone: Europe/Paris
-    last_days: 365 # Number of days of data to retrieve
-    reset: false # If true, the data will be reset before the first data retrieval
+    - name: gazpar2haws # Name of the device in home assistant. It will be used as the entity_ids: sensor.${name}_volume and sensor.${name}_energy.
+      username: "!secret grdf.username"
+      password: "!secret grdf.password"
+      pce_identifier: "!secret grdf.pce_identifier"
+      timezone: Europe/Paris
+      last_days: 365 # Number of days of data to retrieve
+      reset: false # If true, the data will be reset before the first data retrieval
 
 homeassistant:
   host: "!secret homeassistant.host"
@@ -203,8 +210,9 @@ homeassistant.token: ${HA_TOKEN}
 ```
 
 The history is uploaded on the entities with names:
-- sensor.${name}_volume: Volume history in m³.
-- sensor.${name}_energy: Energy history in kWh.
+
+- sensor.${name}\_volume: Volume history in m³.
+- sensor.${name}\_energy: Energy history in kWh.
 
 `${name}` is 'gazpar2haws' defined in the above configuration file. It can be replaced by any other name.
 
@@ -212,16 +220,16 @@ The history is uploaded on the entities with names:
 
 In a Docker environment, the configurations files are instantiated by replacing the environment variables below in the template files:
 
-| Environment variable | Description | Required | Default value |
-|---|---|---|---|
-| GRDF_USERNAME  |  GrDF account user name  | Yes | - |
-| GRDF_PASSWORD  |  GrDF account password (avoid using special characters) | Yes | - |
-| GRDF_PCE_IDENTIFIER  | GrDF meter PCE identifier  | Yes | - |
-| GRDF_SCAN_INTERVAL  | Period in minutes to refresh meter data (0 means one single refresh and stop) | No | 480 (8 hours) |
-| GRDF_LAST_DAYS | Number of days of history data to retrieve  | No | 1095 (3 years) |
-| HOMEASSISTANT_HOST  | Home Assistant instance host name  | Yes | - |
-| HOMEASSISTANT_PORT  | Home Assistant instance port number  | No | 8123 |
-| HOMEASSISTANT_TOKEN  | Home Assistant access token  | Yes | - |
+| Environment variable | Description                                                                   | Required | Default value  |
+| -------------------- | ----------------------------------------------------------------------------- | -------- | -------------- |
+| GRDF_USERNAME        | GrDF account user name                                                        | Yes      | -              |
+| GRDF_PASSWORD        | GrDF account password (avoid using special characters)                        | Yes      | -              |
+| GRDF_PCE_IDENTIFIER  | GrDF meter PCE identifier                                                     | Yes      | -              |
+| GRDF_SCAN_INTERVAL   | Period in minutes to refresh meter data (0 means one single refresh and stop) | No       | 480 (8 hours)  |
+| GRDF_LAST_DAYS       | Number of days of history data to retrieve                                    | No       | 1095 (3 years) |
+| HOMEASSISTANT_HOST   | Home Assistant instance host name                                             | Yes      | -              |
+| HOMEASSISTANT_PORT   | Home Assistant instance port number                                           | No       | 8123           |
+| HOMEASSISTANT_TOKEN  | Home Assistant access token                                                   | Yes      | -              |
 
 You can setup them directly in a docker-compose.yaml file (environment section) or from a Docker command line (-e option).
 
@@ -273,6 +281,3 @@ Please make sure to update tests as appropriate.
 
 Gazpar2HAWS has been initiated for integration with [Home Assistant](https://www.home-assistant.io/) energy dashboard.
 
-
-
-

gazpar2haws-0.2.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+gazpar2haws/__init__.py,sha256=3MCDQdGGmT3FQMKaAB3mBJq7L75T_bJSdpDRjE-pado,58
+gazpar2haws/__main__.py,sha256=KdhkowqJP6L8WTF9FNpTy4ZzDf1OPARm6mVtMclxGFk,3265
+gazpar2haws/bridge.py,sha256=IDunENo7bQ9NDov76IEefAkMOen-6Wc_2NZcHGyk_XI,4601
+gazpar2haws/config_utils.py,sha256=r8BvrA1r8huF-qjvQb0P1JYDLqzDleirLjOcj0xOyyU,2253
+gazpar2haws/gazpar.py,sha256=29RfLxBaBCpoopOBpCX3xh681Ksm5pjZlLu9l3PqTAI,10321
+gazpar2haws/haws.py,sha256=H--UWGECYq9JYlbU6IHLO2btaRXInwoVRZnHIXSA1ts,8169
+gazpar2haws/version.py,sha256=9Iq5Jm63Ev7QquCjhDqa9_KAgHdKl9FJHynq8M6JNrY,83
+gazpar2haws-0.2.1.dist-info/LICENSE,sha256=ajApZPyhVx8AU9wN7DXeRGhoWFqY2ylBZUa5GRhTmok,1073
+gazpar2haws-0.2.1.dist-info/METADATA,sha256=Fbf6evtMKByRJCEWcE179YQHhmtsa4COSYluCIcGaKo,10050
+gazpar2haws-0.2.1.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+gazpar2haws-0.2.1.dist-info/RECORD,,

gazpar2haws-0.2.0a20.dist-info/RECORD

@@ -1,11 +0,0 @@
-gazpar2haws/__init__.py,sha256=3MCDQdGGmT3FQMKaAB3mBJq7L75T_bJSdpDRjE-pado,58
-gazpar2haws/__main__.py,sha256=EMWGYVVfKEJySSvn8fmNfzFZWVjsPefUFyt4gTC506w,3162
-gazpar2haws/bridge.py,sha256=plcXR8y6lH84OSHuUOogNcbM7uua24inoF9SSERKGHo,3539
-gazpar2haws/config_utils.py,sha256=Q_-07kAIqvjjHG27tHLLnyaTAZcFVdt1iRzksz2wy1k,2067
-gazpar2haws/gazpar.py,sha256=jXpOtqWW6fv6BQmVLoA0G7B93HjztY7MemvGnszBXPU,5615
-gazpar2haws/haws.py,sha256=H0Qa01Qtsn3QdnGqIGkXE-Ympf7MSXkbFwAbzaMAodM,6895
-gazpar2haws/version.py,sha256=tJINl5RAPtGkwDz8nWdcM1emyqLY2N2XfgsBHuofz5U,83
-gazpar2haws-0.2.0a20.dist-info/LICENSE,sha256=ajApZPyhVx8AU9wN7DXeRGhoWFqY2ylBZUa5GRhTmok,1073
-gazpar2haws-0.2.0a20.dist-info/METADATA,sha256=WsuiUmV_gYflm_ILcy4pIsuGWBn0rsPOWEb9UxVAIe0,9453
-gazpar2haws-0.2.0a20.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
-gazpar2haws-0.2.0a20.dist-info/RECORD,,