gazpar2haws 0.2.0a20__py3-none-any.whl → 0.2.0b1__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
@@ -40,7 +41,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 +64,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 +74,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,58 @@
-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
+
+import yaml
+
+
+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 = {}
+        self.raw_config = None
+
+    def load_secrets(self):
+        """Load the secrets file."""
+        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,229 @@
-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
+        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"))
+
+        # 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)
+        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
+            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:
+            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.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: gazpar2haws
-Version: 0.2.0a20
+Version: 0.2.0b1
 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
          

gazpar2haws-0.2.0b1.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=s8ENqugNhxTJMAOJzRwVt1YidwxzbPfwdWKx7TLQN7w,3625
+gazpar2haws/config_utils.py,sha256=89ClKudFGxiT_EnzqRhfEvYVm9SeWq6U2xhNjvm3hhs,2161
+gazpar2haws/gazpar.py,sha256=6FyKUKtvn9zlpHbyaUvEYs6uUK7Bnx8LDGB9Nbs_E58,8327
+gazpar2haws/haws.py,sha256=H--UWGECYq9JYlbU6IHLO2btaRXInwoVRZnHIXSA1ts,8169
+gazpar2haws/version.py,sha256=9Iq5Jm63Ev7QquCjhDqa9_KAgHdKl9FJHynq8M6JNrY,83
+gazpar2haws-0.2.0b1.dist-info/LICENSE,sha256=ajApZPyhVx8AU9wN7DXeRGhoWFqY2ylBZUa5GRhTmok,1073
+gazpar2haws-0.2.0b1.dist-info/METADATA,sha256=-TB33G3v3eu9r1Uv33ffcP-zBRMpBQBIY3nezSwYFV4,9452
+gazpar2haws-0.2.0b1.dist-info/WHEEL,sha256=RaoafKOydTQ7I_I3JTrPCg6kUmTgtm4BornzOqyEfJ8,88
+gazpar2haws-0.2.0b1.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,,