gazpar2haws 0.1.0__py3-none-any.whl

CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2024-12-08
+
+First version of the project.

gazpar2haws/__init__.py

@@ -0,0 +1 @@
+from gazpar2haws.version import __version__  # noqa: F401

gazpar2haws/__main__.py

@@ -0,0 +1,91 @@
+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())

gazpar2haws/bridge.py

@@ -0,0 +1,92 @@
+import logging
+import signal
+import asyncio
+from gazpar2haws import config_utils
+from gazpar2haws.gazpar import Gazpar
+from gazpar2haws.haws import HomeAssistantWS
+
+Logger = logging.getLogger(__name__)
+
+
+# ----------------------------------
+class Bridge:
+
+    # ----------------------------------
+    def __init__(self, config: config_utils.ConfigLoader):
+
+        # GrDF scan interval (in seconds)
+        self._grdf_scan_interval = int(config.get("grdf.scan_interval"))
+
+        # Home Assistant configuration
+        ha_host = config.get("homeassistant.host")
+        ha_port = config.get("homeassistant.port")
+        ha_token = config.get("homeassistant.token")
+
+        # Initialize Home Assistant
+        self._homeassistant = HomeAssistantWS(ha_host, ha_port, ha_token)
+
+        # Initialize Gazpar
+        self._gazpar = []
+        for grdf_device_config in config.get("grdf.devices"):
+            self._gazpar.append(Gazpar(grdf_device_config, self._homeassistant))
+
+        # Set up signal handler
+        signal.signal(signal.SIGINT, self.handle_signal)
+        signal.signal(signal.SIGTERM, self.handle_signal)
+
+        # Initialize running flag
+        self._running = False
+
+    # ----------------------------------
+    # Graceful shutdown function
+    def handle_signal(self, signum, frame):
+        print(f"Signal {signum} received. Shutting down gracefully...")
+        Logger.info(f"Signal {signum} received. Shutting down gracefully...")
+        self._running = False
+
+    # ----------------------------------
+    async def run(self):
+
+        # Set running flag
+        self._running = True
+
+        try:
+            while self._running:
+
+                # Connect to Home Assistant
+                await self._homeassistant.connect()
+
+                # Publish Gazpar data to Home Assistant WS
+                Logger.info("Publishing Gazpar data to Home Assistant WS...")
+
+                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("Gazpar data published to Home Assistant WS.")
+
+                # Disconnect from Home Assistant
+                await self._homeassistant.disconnect()
+
+                # Wait 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:
+                    break
+
+                await self._await_with_interrupt(self._grdf_scan_interval * 60, 5)
+        except KeyboardInterrupt:
+            print("Keyboard interrupt detected. Shutting down gracefully...")
+            Logger.info("Keyboard interrupt detected. Shutting down gracefully...")
+
+    # ----------------------------------
+    async def _await_with_interrupt(self, total_sleep_time: int, check_interval: int):
+        elapsed_time = 0
+        while elapsed_time < total_sleep_time:
+            await asyncio.sleep(check_interval)
+            elapsed_time += check_interval
+            # Check if an interrupt signal or external event requires breaking
+            if not self._running:  # Assuming `running` is a global flag
+                break

gazpar2haws/config_utils.py

@@ -0,0 +1,56 @@
+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)

gazpar2haws/gazpar.py

@@ -0,0 +1,114 @@
+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):
+
+        # Eventually reset the sensor in Home Assistant
+        if self._reset:
+            try:
+                await self._homeassistant.clear_statistics([f"sensor.{self._name}"])
+            except Exception:
+                errorMessage = f"Error while resetting the sensor in Home Assistant: {traceback.format_exc()}"
+                Logger.warning(errorMessage)
+                raise Exception(errorMessage)
+
+        # Check the existence of the sensor in Home Assistant
+        try:
+            exists_statistic_id = await self._homeassistant.exists_statistic_id(f"sensor.{self._name}", "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 last statistics from GrDF
+            try:
+                last_statistics = await self._homeassistant.get_last_statistic(f"sensor.{self._name}")
+            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_statistics.get("end") / 1000)
+
+            # Compute the number of days since the last statistics
+            last_days = (datetime.now() - last_date).days
+        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() - timedelta(days=last_days)
+
+        # 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)
+
+        # Fill statistics.
+        daily = data.get(pygazpar.Frequency.DAILY.value)
+        statistics = []
+        for reading in daily:
+            # Parse date format DD/MM/YYYY into datetime.
+            date = datetime.strptime(reading[pygazpar.PropertyName.TIME_PERIOD.value], "%d/%m/%Y")
+
+            # Skip all readings before the last statistic date.
+            if date.date() < last_date.date():
+                continue
+
+            # Set the timezone
+            date = timezone.localize(date)
+
+            statistics.append({
+                "start": date.isoformat(),
+                "state": reading[pygazpar.PropertyName.END_INDEX.value],
+                "sum": reading[pygazpar.PropertyName.END_INDEX.value]
+            })
+
+        # Publish statistics to Home Assistant
+        try:
+            await self._homeassistant.import_statistics(f"sensor.{self._name}", "recorder", "gazpar2haws", "m³", statistics)
+        except Exception:
+            errorMessage = f"Error while importing statistics to Home Assistant: {traceback.format_exc()}"
+            Logger.warning(errorMessage)
+            raise Exception(errorMessage)

gazpar2haws/haws.py

@@ -0,0 +1,191 @@
+import websockets
+import json
+from datetime import datetime, timedelta
+import logging
+
+Logger = logging.getLogger(__name__)
+
+
+# ----------------------------------
+class HomeAssistantWS:
+    def __init__(self, host, port, token):
+        self._host = host
+        self._port = port
+        self._token = token
+        self._websocket = None
+        self._message_id = 1
+
+    # ----------------------------------
+    async def connect(self):
+
+        Logger.debug(f"Connecting to Home Assistant at {self._host}:{self._port}")
+
+        ws_url = f"ws://{self._host}:{self._port}/api/websocket"
+
+        # Connect to the websocket
+        self._websocket = await websockets.connect(ws_url)
+
+        # When a client connects to the server, the server sends out auth_required.
+        connect_response = await self._websocket.recv()
+        connect_response_data = json.loads(connect_response)
+
+        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)
+
+        # 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}
+        await self._websocket.send(json.dumps(auth_message))
+
+        # If the client supplies valid authentication, the authentication phase will complete by the server sending the auth_ok message.
+        auth_response = await self._websocket.recv()
+        auth_response_data = json.loads(auth_response)
+
+        if auth_response_data.get("type") == "auth_invalid":
+            message = f"Authentication failed: {auth_response_data.get('messsage')}"
+            Logger.warning(message)
+            raise Exception(message)
+
+        Logger.debug("Connected to Home Assistant")
+
+    # ----------------------------------
+    async def disconnect(self):
+
+        Logger.debug("Disconnecting from Home Assistant...")
+
+        await self._websocket.close()
+
+        Logger.debug("Disconnected from Home Assistant")
+
+    # ----------------------------------
+    async def send_message(self, message: dict) -> dict:
+
+        Logger.debug("Sending a message...")
+
+        message["id"] = self._message_id
+
+        self._message_id += 1
+
+        await self._websocket.send(json.dumps(message))
+
+        response = await self._websocket.recv()
+
+        response_data = json.loads(response)
+
+        Logger.debug(f"Received response: {response_data}")
+
+        if response_data.get("type") != "result":
+            raise Exception(f"Invalid response message: {response_data}")
+
+        if not response_data.get("success"):
+            raise Exception(f"Request failed: {response_data.get('error')}")
+
+        return response_data.get("result")
+
+    # ----------------------------------
+    async def list_statistic_ids(self, statistic_type: str = None) -> list[str]:
+
+        Logger.debug("Listing statistics IDs...")
+
+        # List statistics IDs message
+        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)
+
+        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:
+
+        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]
+
+        exists_statistic = entity_id in entity_ids
+
+        Logger.debug(f"{entity_id} exists: {exists_statistic}")
+
+        return exists_statistic
+
+    # ----------------------------------
+    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}...")
+
+        # Subscribe to statistics
+        statistics_message = {
+            "type": "recorder/statistics_during_period",
+            "start_time": start_time.isoformat(),
+            "end_time": end_time.isoformat(),
+            "statistic_ids": entity_ids,
+            "period": "day"
+        }
+
+        response = await self.send_message(statistics_message)
+
+        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:
+
+        Logger.debug(f"Getting last statistic for {entity_id}...")
+
+        statistics = await self.statistics_during_period([entity_id], datetime.now() - timedelta(days=30), datetime.now())
+
+        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}...")
+
+        if len(statistics) == 0:
+            Logger.debug("No statistics to import")
+            return
+
+        # Import statistics message
+        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,
+            },
+            "stats": statistics
+        }
+
+        await self.send_message(import_statistics_message)
+
+        Logger.debug(f"Imported {len(statistics)} statistics for {entity_id} from {source}")
+
+    # ----------------------------------
+    async def clear_statistics(self, entity_ids: list[str]):
+
+        Logger.debug(f"Clearing {entity_ids} statistics...")
+
+        # Clear statistics message
+        clear_statistics_message = {
+            "type": "recorder/clear_statistics",
+            "statistic_ids": entity_ids
+        }
+
+        await self.send_message(clear_statistics_message)
+
+        Logger.debug(f"Cleared {entity_ids} statistics")

gazpar2haws/version.py

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

gazpar2haws-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Stéphane Senart
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gazpar2haws-0.1.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.1
+Name: gazpar2haws
+Version: 0.1.0
+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
+Author: Stéphane Senart
+Requires-Python: >=3.12,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: pygazpar (==1.2.5)
+Requires-Dist: pytest-asyncio (>=0.25.0,<0.26.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: websockets (>=14.1,<15.0)
+Description-Content-Type: text/markdown
+
+# gazpar2haws
+Gazpar2HAWS is a gateway that reads data history from the GrDF (French gas provider) meter and send it to Home Assistant using WebSocket interface.
+
+It is compatible with Home Assistant Energy Dashboard and permits to upload the history and keep it updated with the latest readings.
+
+## Installation
+
+Gazpar2HAWS can be installed on any host as a standalone program.
+
+### 1. Using source files
+
+The project requires [Poetry](https://python-poetry.org/) tool for dependency and package management.
+
+```sh
+$ cd /path/to/my_install_folder/
+
+$ git clone https://github.com/ssenart/gazpar2haws.git
+
+$ cd gazpar2haws
+
+$ poetry install
+
+$ poetry shell
+
+```
+
+### 2. Using PIP package
+
+```sh
+$ cd /path/to/my_install_folder/
+
+$ mkdir gazpar2haws
+
+$ cd gazpar2haws
+
+$ python -m venv .venv
+
+$ source .venv/bin/activate
+
+$ pip install gazpar2haws
+
+```
+
+## Usage
+
+### Command line
+
+```sh
+$ python -m gazpar2haws --config /path/to/configuration.yaml --secrets /path/to/secrets.yaml
+```
+
+### Configuration file
+
+The default configuration file is below.
+
+```yaml
+logging:
+  file: log/gazpar2haws.log
+  console: true
+  level: debug
+  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
+    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"
+  port: "!secret homeassistant.port"
+  token: "!secret homeassistant.token"
+```
+
+The default secret file:
+
+```yaml
+grdf.username: ${GRDF_USERNAME}
+grdf.password: ${GRDF_PASSWORD}
+grdf.pce_identifier: ${GRDF_PCE_IDENTIFIER}
+
+homeassistant.host: ${HA_HOST}
+homeassistant.port: ${HA_PORT}
+homeassistant.token: ${HA_TOKEN}
+```
+
+## Contributing
+Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
+
+Please make sure to update tests as appropriate.
+
+## License
+[MIT](https://choosealicense.com/licenses/mit/)
+
+## Project status
+Gazpar2HAWS has been initiated for integration with [Home Assistant](https://www.home-assistant.io/) energy dashboard.
+
+
+
+

gazpar2haws-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+CHANGELOG.md,sha256=8JDG8V_DLBTwnVlZErwlK9PNI-xiwpU6vaqSKavYvKw,316
+gazpar2haws/__init__.py,sha256=yzol8uZSBI7pIRGUmYJ6-vRBwkM4MI3IGf5cQpNsaFw,57
+gazpar2haws/__main__.py,sha256=g8xk0x_kprBHKHLzgf9y9EY2_gKC9V3k4z0n-EDTd-I,3253
+gazpar2haws/bridge.py,sha256=TiPmvRBxzgwOKKmWNXMOaP0pLg-Wls_SmiwHczNEM_4,3466
+gazpar2haws/config_utils.py,sha256=D0lu-3KY-vLEyD2vDN05UABkMnpMJjqw1RuDJVrkGFs,2123
+gazpar2haws/gazpar.py,sha256=4bEp0JDrLAFxbADSoRH76UD3OC8ls5GBhUcoBQ9WQxw,4663
+gazpar2haws/haws.py,sha256=EXs5Tdla4u2BVtupCCLITyvdL_W288LrCxrTzskWSRY,6783
+gazpar2haws/version.py,sha256=ebdTNl4h0hNKmN3Gbs592VJsYbMmrkB47WyZMJevaQo,86
+gazpar2haws-0.1.0.dist-info/LICENSE,sha256=G6JttcnlwcRHYzIcDflSGOVrHTtaP3BEegM2lH00xHw,1094
+gazpar2haws-0.1.0.dist-info/METADATA,sha256=H6EGtnQczzLQKLDwdPtAd2TwAzzVIi82AURA36Khwns,3099
+gazpar2haws-0.1.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+gazpar2haws-0.1.0.dist-info/RECORD,,

gazpar2haws-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.1
+Root-Is-Purelib: true
+Tag: py3-none-any