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

gazpar2haws/__main__.py

@@ -1,10 +1,12 @@
 import argparse
 import asyncio
 import logging
+import sys
 import traceback
 
-from gazpar2haws import __version__, config_utils
+from gazpar2haws import __version__
 from gazpar2haws.bridge import Bridge
+from gazpar2haws.configuration import Configuration
 
 Logger = logging.getLogger(__name__)
 
@@ -16,9 +18,7 @@ async def main():
         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("-v", "--version", action="version", version="Gazpar2HAWS version")
     parser.add_argument(
         "-c",
         "--config",
@@ -38,17 +38,16 @@ async def main():
 
     try:
         # Load configuration files
-        config = config_utils.ConfigLoader(args.config, args.secrets)
-        config.load_secrets()
-        config.load_config()
+        config = Configuration.load(args.config, args.secrets)
 
         print(f"Gazpar2HAWS version: {__version__}")
+        print(f"Running on Python version: {sys.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")
+        logging_file = config.logging.file
+        logging_console = config.logging.console
+        logging_level = config.logging.level
+        logging_format = config.logging.format
 
         # Convert logging level to integer
         if logging_level.upper() == "DEBUG":
@@ -70,14 +69,13 @@ async def main():
             # 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
+            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__}")
+        Logger.info(f"Running on Python version: {sys.version}")
 
         # Log configuration
         Logger.info(f"Configuration:\n{config.dumps()}")
@@ -91,12 +89,10 @@ async def main():
         return 0
 
     except Exception:  # pylint: disable=broad-except
-        errorMessage = (
-            f"An error occured while running Gazpar2HAWS: {traceback.format_exc()}"
-        )
+        errorMessage = f"An error occured while running Gazpar2HAWS: {traceback.format_exc()}"
         Logger.error(errorMessage)
         print(errorMessage)
-        return 1
+        raise
 
 
 # ----------------------------------

gazpar2haws/bridge.py

@@ -2,7 +2,7 @@ import asyncio
 import logging
 import signal
 
-from gazpar2haws import config_utils
+from gazpar2haws.configuration import Configuration
 from gazpar2haws.gazpar import Gazpar
 from gazpar2haws.haws import HomeAssistantWS
 
@@ -13,24 +13,31 @@ Logger = logging.getLogger(__name__)
 class Bridge:
 
     # ----------------------------------
-    def __init__(self, config: config_utils.ConfigLoader):
+    def __init__(self, config: Configuration):
 
         # GrDF scan interval (in seconds)
-        self._grdf_scan_interval = int(config.get("grdf.scan_interval"))
+        self._grdf_scan_interval = config.grdf.scan_interval
 
-        # Home Assistant configuration
-        ha_host = config.get("homeassistant.host")
-        ha_port = config.get("homeassistant.port")
-        ha_endpoint = config.get("homeassistant.endpoint")
-        ha_token = config.get("homeassistant.token")
+        # Home Assistant configuration: host
+        ha_host = config.homeassistant.host
+
+        # Home Assistant configuration: port
+        ha_port = config.homeassistant.port
+
+        # Home Assistant configuration: endpoint
+        ha_endpoint = config.homeassistant.endpoint
+
+        # Home Assistant configuration: token
+        ha_token = config.homeassistant.token.get_secret_value()
 
         # Initialize Home Assistant
         self._homeassistant = HomeAssistantWS(ha_host, ha_port, ha_endpoint, ha_token)
 
         # Initialize Gazpar
         self._gazpar = []
-        for grdf_device_config in config.get("grdf.devices"):
-            self._gazpar.append(Gazpar(grdf_device_config, self._homeassistant))
+
+        for grdf_device_config in config.grdf.devices:
+            self._gazpar.append(Gazpar(grdf_device_config, config.pricing, self._homeassistant))
 
         # Set up signal handler
         signal.signal(signal.SIGINT, self.handle_signal)
@@ -64,9 +71,7 @@ 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.")
 
@@ -74,9 +79,7 @@ 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,18 +1,21 @@
 import os
+from typing import Any
 
 import yaml
 
 
 class ConfigLoader:
-    def __init__(self, config_file="config.yaml", secrets_file="secrets.yaml"):
+    def __init__(self, config_file: str, secrets_file: str):
         self.config_file = config_file
         self.secrets_file = secrets_file
-        self.config = {}
-        self.secrets = {}
+        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)
@@ -26,9 +29,7 @@ class ConfigLoader:
                 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."
-            )
+            raise FileNotFoundError(f"Configuration file '{self.config_file}' not found.")
 
     def _resolve_secrets(self, data):
         """Recursively resolve `!secret` keys in the configuration."""
@@ -54,5 +55,8 @@ class ConfigLoader:
         except (KeyError, TypeError):
             return default
 
+    def dict(self) -> dict:
+        return self.config
+
     def dumps(self) -> str:
         return yaml.dump(self.raw_config)

gazpar2haws/configuration.py

@@ -0,0 +1,28 @@
+from typing import Optional
+
+import yaml
+from pydantic import BaseModel
+
+from gazpar2haws import config_utils
+from gazpar2haws.model import Grdf, HomeAssistant, Logging, Pricing
+
+
+class Configuration(BaseModel):
+
+    logging: Logging
+    grdf: Grdf
+    homeassistant: HomeAssistant
+    pricing: Optional[Pricing] = None
+
+    @classmethod
+    def load(cls, config_file: str, secrets_file: str):
+
+        # Load configuration
+        config = config_utils.ConfigLoader(config_file, secrets_file)
+        config.load_secrets()
+        config.load_config()
+
+        return cls(**config.dict())
+
+    def dumps(self) -> str:
+        return yaml.dump(self.model_dump(mode="json"), allow_unicode=True)

gazpar2haws/date_array.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+
+import datetime as dt
+from datetime import timedelta
+from typing import Optional, overload
+
+import numpy as np
+from pydantic import BaseModel, ConfigDict, model_validator
+
+
+class DateArray(BaseModel):  # pylint: disable=too-few-public-methods
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    name: Optional[str] = None
+    start_date: dt.date
+    end_date: dt.date
+    array: Optional[np.ndarray] = None
+    initial_value: Optional[float] = None
+
+    @model_validator(mode="after")
+    def set_array(self):
+        if self.array is None:
+            if self.initial_value is not None:
+                self.array = np.full((self.end_date - self.start_date).days + 1, self.initial_value)
+            else:
+                self.array = np.zeros((self.end_date - self.start_date).days + 1)
+        return self
+
+    # ----------------------------------
+    def get(self, date: dt.date) -> float:
+
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+
+        return self.array[(date - self.start_date).days]
+
+    # ----------------------------------
+    def cumsum(self) -> DateArray:
+
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+
+        result = DateArray(name=f"cumsum_{self.name}", start_date=self.start_date, end_date=self.end_date)
+        result.array = np.cumsum(self.array)
+        return result
+
+    # ----------------------------------
+    def is_aligned_with(self, other: DateArray) -> bool:
+
+        return (
+            self.start_date == other.start_date and self.end_date == other.end_date and len(self) == len(other)
+        )  # pylint: disable=protected-access
+
+    # ----------------------------------
+    @overload
+    def __getitem__(self, index: int) -> float: ...
+
+    @overload
+    def __getitem__(self, date: dt.date) -> float: ...
+
+    @overload
+    def __getitem__(self, date_slice: slice) -> DateArray: ...
+
+    def __getitem__(self, key):
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+        if isinstance(key, int):
+            return self.array[key]
+        if isinstance(key, dt.date):
+            return self.get(key)
+        if isinstance(key, slice):
+            start_date: dt.date = key.start  # type: ignore
+            end_date: dt.date = key.stop  # type: ignore
+            start_index: int = (start_date - self.start_date).days
+            end_index: int = (end_date - self.start_date).days
+            if start_index < 0 or end_index > len(self.array):
+                raise ValueError(
+                    f"Date slice [{start_date}:{end_date}] is out of range [{self.start_date}:{self.end_date}]"
+                )
+            return DateArray(
+                name=self.name,
+                start_date=start_date,
+                end_date=end_date + timedelta(-1),
+                array=self.array[start_index:end_index],
+            )
+        raise TypeError("Key must be a date or a slice of dates")
+
+    # ----------------------------------
+    @overload
+    def __setitem__(self, index: int, value: float): ...
+
+    @overload
+    def __setitem__(self, date: dt.date, value: float): ...
+
+    @overload
+    def __setitem__(self, date_slice: slice, value: float): ...
+
+    @overload
+    def __setitem__(self, date_slice: slice, value: DateArray): ...
+
+    def __setitem__(self, key, value):
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+        if isinstance(key, int):
+            self.array[key] = value
+        elif isinstance(key, dt.date):
+            self.array[(key - self.start_date).days] = value
+        elif isinstance(key, slice):
+            start_date: dt.date = key.start  # type: ignore
+            end_date: dt.date = key.stop  # type: ignore
+            start_index: int = (start_date - self.start_date).days
+            end_index: int = (end_date - self.start_date).days
+            if start_index < 0 or end_index > len(self.array):
+                raise ValueError(
+                    f"Date slice [{start_date}:{end_date}] is out of range [{self.start_date}:{self.end_date}]"
+                )
+            if isinstance(value, float):
+                self.array[start_index:end_index] = value
+            elif isinstance(value, DateArray):
+                self.array[start_index:end_index] = value.array
+            else:
+                raise TypeError("Value must be a float or a DateArray")
+        else:
+            raise TypeError("Key must be a date or a slice of dates")
+
+    # ----------------------------------
+    def __len__(self) -> int:
+
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+
+        return len(self.array)
+
+    # ----------------------------------
+    def __iter__(self):
+        self._index = 0  # pylint: disable=attribute-defined-outside-init
+        return self
+
+    # ----------------------------------
+    def __next__(self):
+        if self._index < len(self.array):
+            current_date = self.start_date + dt.timedelta(days=self._index)
+            result = (current_date, self.array[self._index])
+            self._index += 1
+            return result
+        raise StopIteration
+
+    # ----------------------------------
+    @overload
+    def __add__(self, other: DateArray) -> DateArray: ...
+
+    @overload
+    def __add__(self, other: float) -> DateArray: ...
+
+    def __add__(self, other) -> DateArray:
+
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+
+        if isinstance(other, (int, float)):
+            result = DateArray(name=self.name, start_date=self.start_date, end_date=self.end_date)
+            result.array = self.array + other
+            return result
+        if isinstance(other, DateArray):
+            if other.array is None:
+                raise ValueError("Array is not initialized")
+            if not self.is_aligned_with(other):
+                raise ValueError(f"Date arrays {self} and {other} are not aligned")
+            result = DateArray(name=self.name, start_date=self.start_date, end_date=self.end_date)
+            result.array = self.array + other.array  # pylint: disable=protected-access
+            return result
+
+        raise TypeError("Other must be a date array or a number")
+
+    # ----------------------------------
+    @overload
+    def __sub__(self, other: DateArray) -> DateArray: ...
+
+    @overload
+    def __sub__(self, other: float) -> DateArray: ...
+
+    def __sub__(self, other) -> DateArray:
+
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+
+        if isinstance(other, (int, float)):
+            result = DateArray(name=self.name, start_date=self.start_date, end_date=self.end_date)
+            result.array = self.array - other
+            return result
+        if isinstance(other, DateArray):
+            if other.array is None:
+                raise ValueError("Array is not initialized")
+            if not self.is_aligned_with(other):
+                raise ValueError(f"Date arrays {self} and {other} are not aligned")
+            result = DateArray(name=self.name, start_date=self.start_date, end_date=self.end_date)
+            result.array = self.array - other.array  # pylint: disable=protected-access
+            return result
+
+        raise TypeError("Other must be a date array or a number")
+
+    # ----------------------------------
+    @overload
+    def __mul__(self, other: DateArray) -> DateArray: ...
+
+    @overload
+    def __mul__(self, other: float) -> DateArray: ...
+
+    def __mul__(self, other) -> DateArray:
+
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+
+        if isinstance(other, (int, float)):
+            result = DateArray(name=self.name, start_date=self.start_date, end_date=self.end_date)
+            result.array = self.array * other
+            return result
+        if isinstance(other, DateArray):
+            if other.array is None:
+                raise ValueError("Array is not initialized")
+            if not self.is_aligned_with(other):
+                raise ValueError(f"Date arrays {self} and {other} are not aligned")
+            result = DateArray(name=self.name, start_date=self.start_date, end_date=self.end_date)
+            result.array = self.array * other.array  # pylint: disable=protected-access
+            return result
+
+        raise TypeError("Other must be a date array or a number")
+
+    # ----------------------------------
+    @overload
+    def __truediv__(self, other: DateArray) -> DateArray: ...
+
+    @overload
+    def __truediv__(self, other: float) -> DateArray: ...
+
+    def __truediv__(self, other) -> DateArray:
+
+        if self.array is None:
+            raise ValueError("Array is not initialized")
+
+        if isinstance(other, (int, float)):
+            result = DateArray(name=self.name, start_date=self.start_date, end_date=self.end_date)
+            result.array = self.array / other
+            return result
+        if isinstance(other, DateArray):
+            if other.array is None:
+                raise ValueError("Array is not initialized")
+            if not self.is_aligned_with(other):
+                raise ValueError(f"Date arrays {self} and {other} are not aligned")
+            result = DateArray(name=self.name, start_date=self.start_date, end_date=self.end_date)
+            result.array = self.array / other.array  # pylint: disable=protected-access
+            return result
+
+        raise TypeError("Other must be a date array or a number")
+
+    # ----------------------------------
+    def __str__(self) -> str:
+
+        return f"DateArray(name={self.name}, start_date={self.start_date}, end_date={self.end_date}, array={self.array}, slots={(self.end_date - self.start_date).days + 1}, length={len(self)})"