weheat 2024.7.8__tar.gz

weheat-2024.7.8/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.1
+Name: weheat
+Version: 2024.7.8
+Summary: Weheat Backend client
+Home-page: https://github.com/wefabricate/wh-python
+Author: Jesper Raemaekers
+Author-email: jesper.raemaekers@wefabricate.com
+Keywords: OpenAPI,OpenAPI-Generator,Weheat Backend
+Description-Content-Type: text/markdown
+Requires-Dist: urllib3<2.1.0,>=1.25.3
+Requires-Dist: python-dateutil
+Requires-Dist: pydantic<2,>=1.10.5
+Requires-Dist: aenum
+
+# Weheat backend client
+
+This is a client for the Weheat backend. It is automatically generated from the OpenAPI specification.
+
+## Requirements.
+
+Python 3.7+
+
+## Installation & Usage
+
+You can install directly using:
+
+```sh
+pip install weheat
+```
+
+Then import the package:
+
+```python
+import weheat
+```
+
+
+
+## Getting Started
+
+After installation, you can now use the client to interact with the Weheat backend.
+
+```python
+import datetime
+from keycloak import KeycloakOpenID  # install with pip install python-keycloak
+from weheat import ApiClient, Configuration, HeatPumpApi, HeatPumpLogApi, EnergyLogApi
+
+# input your information here
+auth_url = 'https://auth.weheat.nl/auth/'
+api_url = 'https://api.weheat.nl'
+realm_name = 'Weheat'
+my_client_id = 'WeheatCommunityAPI'  # client ID and secret provided by Weheat
+my_client_secret = ''
+username = ''  # username and password used for the online portal
+password = ''
+my_heat_pump_id = ''  # your heat pump UUID
+
+# Get the access token from keycloak
+keycloak_open_id = KeycloakOpenID(server_url=auth_url,
+                                  client_id=my_client_id,
+                                  realm_name=realm_name,
+                                  client_secret_key=my_client_secret)
+
+token_response = keycloak_open_id.token(username, password)
+keycloak_open_id.logout(token_response['refresh_token'])
+
+# Create the cinfiguration object
+config = Configuration(host=api_url, access_token=token_response['access_token'])
+
+# with the client the APIs can be accessed
+with ApiClient(configuration=config) as client:
+    # Getting all heat pumps that the user has access to
+    response = HeatPumpApi(client).api_v1_heat_pumps_get_with_http_info()
+
+    if response.status_code == 200:
+        print(f'My heat pump: {response.data}')
+
+    # Getting the latest log of the heat pump
+    response = HeatPumpLogApi(client).api_v1_heat_pumps_heat_pump_id_logs_latest_get_with_http_info(
+        heat_pump_id=my_heat_pump_id)
+
+    if response.status_code == 200:
+        print(f'My heat pump logs: {response.data}')
+
+    # Getting the energy logs of the heat pump in a specific period
+    # interval can be  "Minute", "FiveMinute", "FifteenMinute", "Hour", "Day", "Week", "Month", "Year"
+    response = EnergyLogApi(client).api_v1_energy_logs_heat_pump_id_get_with_http_info(heat_pump_id=my_heat_pump_id,
+                                                                                       start_time=datetime.datetime(
+                                                                                           2024, 6,
+                                                                                           22, 0, 0,
+                                                                                           0),
+                                                                                       end_time=datetime.datetime(2024,
+                                                                                                                  6, 22,
+                                                                                                                  15, 0,
+                                                                                                                  0),
+                                                                                       interval='Hour')
+
+    if response.status_code == 200:
+        print(f'My energy logs: {response.data}')
+
+
+```
+
+
+

weheat-2024.7.8/README.md

@@ -0,0 +1,91 @@
+# Weheat backend client
+
+This is a client for the Weheat backend. It is automatically generated from the OpenAPI specification.
+
+## Requirements.
+
+Python 3.7+
+
+## Installation & Usage
+
+You can install directly using:
+
+```sh
+pip install weheat
+```
+
+Then import the package:
+
+```python
+import weheat
+```
+
+
+
+## Getting Started
+
+After installation, you can now use the client to interact with the Weheat backend.
+
+```python
+import datetime
+from keycloak import KeycloakOpenID  # install with pip install python-keycloak
+from weheat import ApiClient, Configuration, HeatPumpApi, HeatPumpLogApi, EnergyLogApi
+
+# input your information here
+auth_url = 'https://auth.weheat.nl/auth/'
+api_url = 'https://api.weheat.nl'
+realm_name = 'Weheat'
+my_client_id = 'WeheatCommunityAPI'  # client ID and secret provided by Weheat
+my_client_secret = ''
+username = ''  # username and password used for the online portal
+password = ''
+my_heat_pump_id = ''  # your heat pump UUID
+
+# Get the access token from keycloak
+keycloak_open_id = KeycloakOpenID(server_url=auth_url,
+                                  client_id=my_client_id,
+                                  realm_name=realm_name,
+                                  client_secret_key=my_client_secret)
+
+token_response = keycloak_open_id.token(username, password)
+keycloak_open_id.logout(token_response['refresh_token'])
+
+# Create the cinfiguration object
+config = Configuration(host=api_url, access_token=token_response['access_token'])
+
+# with the client the APIs can be accessed
+with ApiClient(configuration=config) as client:
+    # Getting all heat pumps that the user has access to
+    response = HeatPumpApi(client).api_v1_heat_pumps_get_with_http_info()
+
+    if response.status_code == 200:
+        print(f'My heat pump: {response.data}')
+
+    # Getting the latest log of the heat pump
+    response = HeatPumpLogApi(client).api_v1_heat_pumps_heat_pump_id_logs_latest_get_with_http_info(
+        heat_pump_id=my_heat_pump_id)
+
+    if response.status_code == 200:
+        print(f'My heat pump logs: {response.data}')
+
+    # Getting the energy logs of the heat pump in a specific period
+    # interval can be  "Minute", "FiveMinute", "FifteenMinute", "Hour", "Day", "Week", "Month", "Year"
+    response = EnergyLogApi(client).api_v1_energy_logs_heat_pump_id_get_with_http_info(heat_pump_id=my_heat_pump_id,
+                                                                                       start_time=datetime.datetime(
+                                                                                           2024, 6,
+                                                                                           22, 0, 0,
+                                                                                           0),
+                                                                                       end_time=datetime.datetime(2024,
+                                                                                                                  6, 22,
+                                                                                                                  15, 0,
+                                                                                                                  0),
+                                                                                       interval='Hour')
+
+    if response.status_code == 200:
+        print(f'My energy logs: {response.data}')
+
+
+```
+
+
+

weheat-2024.7.8/pyproject.toml

@@ -0,0 +1,30 @@
+[tool.poetry]
+name = "weheat"
+version = "2024.07.08"
+description = "Weheat Backend"
+authors = ["Jesper Raemaekers <jesper.raemaekers@wefabricate.com>", "Kjell van Straaten <kjell.van.straaten@wefabricate.com>"]
+license = "NoLicense"
+readme = "README.md"
+repository = "https://github.com/wefabricate/wh-python"
+keywords = ["OpenAPI", "OpenAPI-Generator", "Weheat Backend"]
+include = ["weheat/py.typed"]
+
+[tool.poetry.dependencies]
+python = "^3.7"
+
+urllib3 = ">= 1.25.3"
+python-dateutil = ">=2.8.2"
+pydantic = "^1.10.5, <2"
+aenum = ">=3.1.11"
+
+[tool.poetry.dev-dependencies]
+pytest = ">=7.2.1"
+tox = ">=3.9.0"
+flake8 = ">=4.0.0"
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.pylint.'MESSAGES CONTROL']
+extension-pkg-whitelist = "pydantic"

weheat-2024.7.8/setup.cfg

@@ -0,0 +1,7 @@
+[flake8]
+max-line-length = 99
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

weheat-2024.7.8/setup.py

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+"""
+    Weheat Backend
+
+    This is the backend for the Weheat project
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+import pathlib
+
+from setuptools import setup, find_packages  # noqa: H301
+
+# To install the library, run the following
+#
+# python setup.py install
+#
+# prerequisite: setuptools
+# http://pypi.python.org/pypi/setuptools
+NAME = "weheat"
+VERSION = "2024.07.08"
+PYTHON_REQUIRES = ">=3.7"
+REQUIRES = [
+    "urllib3 >= 1.25.3, < 2.1.0",
+    "python-dateutil",
+    "pydantic >= 1.10.5, < 2",
+    "aenum"
+]
+
+setup(
+    name=NAME,
+    version=VERSION,
+    description="Weheat Backend client",
+    author="Jesper Raemaekers",
+    author_email="jesper.raemaekers@wefabricate.com",
+    url="https://github.com/wefabricate/wh-python",
+    keywords=["OpenAPI", "OpenAPI-Generator", "Weheat Backend"],
+    install_requires=REQUIRES,
+    packages=find_packages(exclude=["test", "tests"]),
+    include_package_data=True,
+    long_description_content_type='text/markdown',
+    long_description=pathlib.Path("README.md").read_text(),  # noqa: E501
+    package_data={"weheat": ["py.typed"]},
+)

weheat-2024.7.8/weheat/__init__.py

@@ -0,0 +1,42 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+    Weheat Backend
+
+    This is the backend for the Weheat project
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+__version__ = "2024.07.08"
+
+# import apis into sdk package
+from weheat.api.energy_log_api import EnergyLogApi
+from weheat.api.heat_pump_api import HeatPumpApi
+from weheat.api.heat_pump_log_api import HeatPumpLogApi
+
+# import ApiClient
+from weheat.api_response import ApiResponse
+from weheat.api_client import ApiClient
+from weheat.configuration import Configuration
+from weheat.exceptions import OpenApiException
+from weheat.exceptions import ApiTypeError
+from weheat.exceptions import ApiValueError
+from weheat.exceptions import ApiKeyError
+from weheat.exceptions import ApiAttributeError
+from weheat.exceptions import ApiException
+
+# import models into sdk package
+from weheat.models.device_state import DeviceState
+from weheat.models.energy_view_dto import EnergyViewDto
+from weheat.models.heat_pump_log_view_dto import HeatPumpLogViewDto
+from weheat.models.raw_heat_pump_log_dto import RawHeatPumpLogDto
+from weheat.models.read_all_heat_pump_dto import ReadAllHeatPumpDto
+from weheat.models.read_heat_pump_dto import ReadHeatPumpDto
+

weheat-2024.7.8/weheat/abstractions/__init__.py

@@ -0,0 +1,3 @@
+from weheat.abstractions.auth import AbstractAuth
+from weheat.abstractions.discovery import HeatPumpDiscovery
+from weheat.abstractions.heat_pump import HeatPump

weheat-2024.7.8/weheat/abstractions/auth.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from aiohttp import ClientSession, ClientResponse
+
+
+class AbstractAuth(ABC):
+    """Abstract class to make authenticated requests."""
+
+    def __init__(self, websession: ClientSession, host: str) -> None:
+        """Initialize the auth."""
+        self.websession = websession
+        self.host = host
+
+    @abstractmethod
+    async def async_get_access_token(self) -> str:
+        """Return a valid access token."""
+
+    async def request(self, method, url, **kwargs) -> ClientResponse:
+        """Make a request."""
+        headers = kwargs.get("headers")
+
+        if headers is None:
+            headers = {}
+        else:
+            headers = dict(headers)
+
+        access_token = await self.async_get_access_token()
+        headers["authorization"] = f"Bearer {access_token}"
+
+        return await self.websession.request(
+            method,
+            f"{self.host}/{url}",
+            **kwargs,
+            headers=headers,
+        )

weheat-2024.7.8/weheat/abstractions/discovery.py

@@ -0,0 +1,47 @@
+from dataclasses import dataclass
+
+from weheat.configuration import Configuration
+from weheat.api_client import ApiClient
+from weheat.api.heat_pump_api import HeatPumpApi
+
+
+class HeatPumpDiscovery:
+    @dataclass
+    class HeatPumpInfo:
+        uuid: str
+        name: str
+        model: str
+        sn : str
+        has_dhw: bool = False
+
+    @staticmethod
+    def discover(api_url: str, access_token: str) -> list[HeatPumpInfo]:
+        discovered_pumps = []
+
+        config = Configuration(host=api_url, access_token=access_token)
+
+        with ApiClient(configuration=config) as client:
+            # try:
+            response = HeatPumpApi(client).api_v1_heat_pumps_get_with_http_info()
+            if response.status_code == 200:
+                for pump in response.data:
+                    model_string = "BlackBird P80 heat pump"
+                    if pump.model == 1:
+                        model_string = "BlackBird P60 heat pump"
+                    elif pump.model == 2:
+                        model_string = "Sparrow P60 heat pump"
+
+                    dhw = False
+                    if pump.dhw_type is not None and pump.dhw_type == 1:
+                        dhw = True
+
+                    discovered_pumps.append(
+                        HeatPumpDiscovery.HeatPumpInfo(
+                            uuid=pump.id,
+                            name=pump.name,
+                            model=model_string,
+                            sn=pump.serial_number,
+                            has_dhw=dhw,
+                        )
+                    )
+        return discovered_pumps

weheat-2024.7.8/weheat/abstractions/heat_pump.py

@@ -0,0 +1,150 @@
+from enum import Enum, auto
+from weheat.configuration import Configuration
+from weheat.api_client import ApiClient
+from weheat.api.heat_pump_log_api import HeatPumpLogApi
+
+
+class HeatPump:
+    class State(Enum):
+        UNDEFINED = auto()
+        STANDBY = auto()
+        WATER_CHECK = auto()
+        HEATING = auto()
+        COOLING = auto()
+        DHW = auto()
+        LEGIONELLA_PREVENTION = auto()
+        DEFROSTING = auto()
+        SELF_TEST = auto()
+        MANUAL_CONTROL = auto()
+
+    def __init__(self, api_url: str, uuid: str) -> None:
+        self._api_url = api_url
+        self._uuid = uuid
+        self._last_log = None
+
+    def get_status(self, access_token: str):
+        try:
+            config = Configuration(host=self._api_url, access_token=access_token)
+
+            with ApiClient(configuration=config) as client:
+                response = HeatPumpLogApi(
+                    client
+                ).api_v1_heat_pumps_heat_pump_id_logs_latest_get_with_http_info(
+                    heat_pump_id=self._uuid
+                )
+                if response.status_code == 200:
+                    self._last_log = response.data
+        except Exception as e:
+            self._last_log = None
+            raise e
+
+    def _update_properties(self):
+        pass
+
+    def _if_available(self, key):
+        if self._last_log is not None and hasattr(self._last_log, key):
+            return getattr(self._last_log, key)
+        return None
+
+    def __str__(self):
+        return f"WeheatHeatPump(uuid={self._uuid}, last update={self._if_available('timestamp')})"
+
+    def __repr__(self):
+        return self.__str__()
+
+    @property
+    def water_inlet_temperature(self):
+        return self._if_available("t_water_in")
+
+    @property
+    def water_outlet_temperature(self):
+        return self._if_available("t_water_out")
+
+    @property
+    def water_house_in_temperature(self):
+        return self._if_available("t_water_house_in")
+
+    @property
+    def air_inlet_temperature(self):
+        return self._if_available("t_air_in")
+
+    @property
+    def air_outlet_temperature(self):
+        return self._if_available("t_air_out")
+
+    @property
+    def thermostat_water_setpoint(self):
+        return self._if_available("t_thermostat_setpoint")
+
+    @property
+    def thermostat_room_temperature(self):
+        return self._if_available("t_room")
+
+    @property
+    def thermostat_room_temperature_setpoint(self):
+        return self._if_available("t_room_target")
+
+    @property
+    def thermostat_on_off_state(self):
+        return self._if_available("on_off_thermostat_state")
+
+    @property
+    def power_input(self):
+        return self._if_available("cm_mass_power_in")
+
+    @property
+    def power_output(self):
+        return self._if_available("cm_mass_power_out")
+
+    @property
+    def cop(self):
+        """
+        Returns the coefficient of performance of the heat pump.
+        Note that this is calculated from a singular log entry and might not be accurate when the
+        heat pump is changing its output power or switching states
+        """
+        input = self.power_input
+        output = self.power_output
+        if input is not None and output is not None and input != 0:
+            return output / input
+
+    @property
+    def inside_unit_water_pump_state(self):
+        return self._if_available("control_bridge_status_decoded_water_pump")
+
+    @property
+    def inside_unit_auxilary_pump_state(self):
+        return self._if_available("control_bridge_status_decoded_water_pump2")
+
+    @property
+    def inside_unit_dhw_valve_or_pump_state(self):
+        return self._if_available("control_bridge_status_decoded_dhw_valve")
+
+    @property
+    def inside_unit_gas_boiler_state(self):
+        return self._if_available("control_bridge_status_decoded_gas_boiler")
+
+    @property
+    def heat_pump_state(self) -> State:
+        numeric_state = self._if_available("state")
+        if numeric_state is None:
+            return self.State.UNDEFINED
+
+        if numeric_state == 40:
+            return self.State.STANDBY
+        elif numeric_state == 70:
+            return self.State.HEATING
+        elif numeric_state == 130:
+            return self.State.COOLING
+        elif numeric_state == 150:
+            return self.State.DHW
+        elif numeric_state == 160:
+            return self.State.LEGIONELLA_PREVENTION
+        elif numeric_state == 170:
+            return self.State.SELF_TEST
+        elif numeric_state == 180:
+            return self.State.MANUAL_CONTROL
+        elif numeric_state == 200:
+            return self.State.DEFROSTING
+        else:
+            return self.State.UNDEFINED

weheat-2024.7.8/weheat/api/__init__.py

@@ -0,0 +1,6 @@
+# flake8: noqa
+
+# import apis into api package
+from weheat.api.energy_log_api import EnergyLogApi
+from weheat.api.heat_pump_api import HeatPumpApi
+from weheat.api.heat_pump_log_api import HeatPumpLogApi