weheat 2025.1.15rc2__py3-none-any.whl → 2025.2.22__py3-none-any.whl

weheat/abstractions/__init__.py

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

weheat/abstractions/heat_pump.py

@@ -10,13 +10,17 @@ from weheat.api_client import ApiClient
 from weheat.api.heat_pump_log_api import HeatPumpLogApi
 from weheat.api.energy_log_api import EnergyLogApi
 from datetime import datetime, timedelta
+from typing import TypeVar, Union, Optional
 
 # before this date no energy logs are available, so start from this point onwards
 START_DATE = datetime(2023, 1, 1, 0, 0, 0)
 
+T = TypeVar("T", bool, int, float)
+
 
 class HeatPump:
     """Heat pump class representing a heat pump."""
+
     class State(Enum):
         STANDBY = auto()
         WATER_CHECK = auto()
@@ -28,16 +32,22 @@ class HeatPump:
         SELF_TEST = auto()
         MANUAL_CONTROL = auto()
 
-    def __init__(self, api_url: str, uuid: str, client_session:aiohttp.ClientSession|None = None) -> None:
+    def __init__(self, api_url: str, uuid: str, client_session: aiohttp.ClientSession | None = None) -> None:
         self._api_url = api_url
         self._uuid = uuid
         self._last_log = None
-        self._energy_consumption = None
-        self._energy_output = None
-        self._nominal_max_power = None
+        self._energy_consumption: Union[float, None] = None
+        self._energy_output: Union[float, None] = None
+        self._nominal_max_power: Union[float, None] = None
         self._client = client_session
 
-    async def async_get_status(self, access_token: str):
+    async def async_get_status(self, access_token: str) -> None:
+        """Updates the heat pump instance with data from the API."""
+        await self.async_get_logs(access_token)
+        await self.async_get_energy(access_token)
+        
+        
+    async def async_get_logs(self, access_token: str) -> None:
         """Updates the heat pump instance with data from the API."""
         try:
             config = Configuration(host=self._api_url, access_token=access_token, client_session=self._client)
@@ -45,26 +55,39 @@ class HeatPump:
             async with ApiClient(configuration=config) as client:
                 # Set the max power once
                 if self._nominal_max_power is None:
-                    response = await HeatPumpApi(client).api_v1_heat_pumps_heat_pump_id_get_with_http_info(heat_pump_id=self._uuid)
+                    response = await HeatPumpApi(client).api_v1_heat_pumps_heat_pump_id_get_with_http_info(
+                        heat_pump_id=self._uuid)
 
                     if response.status_code == 200:
                         self._set_nominal_max_power_for_model(response.data.model)
 
-
                 response = await HeatPumpLogApi(
                     client
                 ).api_v1_heat_pumps_heat_pump_id_logs_latest_get_with_http_info(
-                    heat_pump_id=self._uuid                )
+                    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
+
+
+    async def async_get_energy(self, access_token: str) -> None:
+        """Updates the heat pump instance with data from the API."""
+        try:
+            config = Configuration(host=self._api_url, access_token=access_token, client_session=self._client)
+
+            async with ApiClient(configuration=config) as client:
                 # Also get all energy totals form past years and add them together
                 # As end time pick today + 1 day to avoid issues with timezones
-                response = await EnergyLogApi(client).api_v1_energy_logs_heat_pump_id_get_with_http_info(heat_pump_id=self._uuid,
-                                                                                start_time=START_DATE,
-                                                                                end_time=datetime.now() + timedelta(days=1),
-                                                                                interval='Month')
+                response = await EnergyLogApi(client).api_v1_energy_logs_heat_pump_id_get_with_http_info(
+                    heat_pump_id=self._uuid,
+                    start_time=START_DATE,
+                    end_time=datetime.now() + timedelta(days=1),
+                    interval='Month')
 
                 if response.status_code == 200:
                     # aggregate the energy consumption
@@ -82,109 +105,112 @@ class HeatPump:
                         self._energy_output += year.total_e_out_dhw
                         self._energy_output += year.total_e_out_dhw_defrost
 
-
-
         except Exception as e:
-            self._last_log = None
             self._energy_consumption = None
-            raise e
+            self._energy_output = None
 
-    def _if_available(self, key):
+    def _if_available(self, key: str) -> Optional[T]:
         """Returns the value from the last logged value if available. None otherwise."""
         if self._last_log is not None and hasattr(self._last_log, key):
             return getattr(self._last_log, key)
         return None
 
-    def _set_nominal_max_power_for_model(self, model_id:int):
+    def _set_nominal_max_power_for_model(self, model_id: int) -> None:
         # These numbers are the rpm at 100% power in the portal
         # RPM can go above 100% if the limit is increased in the portal.
         # except for the Flint, that cannot go above 100%.
         if model_id == 1:
-            #BB60
+            # BB60
             self._nominal_max_power = 5280
         elif 2 <= model_id <= 4:
-            #SP60
+            # SP60
             self._nominal_max_power = 5280
         elif model_id == 5:
             # Flint
             self._nominal_max_power = 5400
         else:
-            #BB80
+            # BB80
             self._nominal_max_power = 4500
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"WeheatHeatPump(uuid={self._uuid}, last update={self._if_available('timestamp')})"
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.__str__()
 
     @property
-    def water_inlet_temperature(self):
+    def raw_content(self) -> Optional[dict]:
+        if self._last_log is not None:
+            return vars(self._last_log) # type: ignore[unreachable]
+        return None
+
+    @property
+    def water_inlet_temperature(self) -> Union[float, None]:
         """The heat pump water inlet temperature."""
         return self._if_available("t_water_in")
 
     @property
-    def water_outlet_temperature(self):
+    def water_outlet_temperature(self) -> Union[float, None]:
         """The heat pump water outlet temperature."""
         return self._if_available("t_water_out")
 
     @property
-    def water_house_in_temperature(self):
+    def water_house_in_temperature(self) -> Union[float, None]:
         """The water house in temperature."""
         return self._if_available("t_water_house_in")
 
     @property
-    def air_inlet_temperature(self):
+    def air_inlet_temperature(self) -> Union[float, None]:
         """The heat pump air inlet temperature."""
         return self._if_available("t_air_in")
 
     @property
-    def air_outlet_temperature(self):
+    def air_outlet_temperature(self) -> Union[float, None]:
         """The heat pump air outlet temperature."""
         return self._if_available("t_air_out")
 
     @property
-    def thermostat_water_setpoint(self):
+    def thermostat_water_setpoint(self) -> Union[float, None]:
         """The  thermostat water setpoint."""
         return self._if_available("t_thermostat_setpoint")
 
     @property
-    def thermostat_room_temperature(self):
+    def thermostat_room_temperature(self) -> Union[float, None]:
         """The thermostat current room temperature."""
         return self._if_available("t_room")
 
     @property
-    def thermostat_room_temperature_setpoint(self):
+    def thermostat_room_temperature_setpoint(self) -> Union[float, None]:
         """The thermostat room temperature setpoint."""
         return self._if_available("t_room_target")
 
     @property
-    def thermostat_on_off_state(self):
+    def thermostat_on_off_state(self) -> Union[bool, None]:
         """The thermostat on/off state."""
         return self._if_available("on_off_thermostat_state")
 
     @property
-    def power_input(self):
+    def power_input(self) -> Union[float, None]:
         """The heat pumps power input."""
         return self._if_available("cm_mass_power_in")
 
     @property
-    def power_output(self):
+    def power_output(self) -> Union[float, None]:
         """The heat pumps hydraulic output power."""
         return self._if_available("cm_mass_power_out")
 
     @property
-    def dhw_top_temperature(self):
+    def dhw_top_temperature(self) -> Union[float, None]:
         """The DHW vessel top temperature."""
         return self._if_available("t1")
 
     @property
-    def dhw_bottom_temperature(self):
+    def dhw_bottom_temperature(self) -> Union[float, None]:
         """The DHW vessel bottom temperature."""
         return self._if_available("t2")
 
     @property
-    def cop(self):
+    def cop(self) -> Union[float, None]:
         """
         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
@@ -194,34 +220,35 @@ class HeatPump:
         output = self.power_output
         if input is not None and output is not None and input != 0:
             return output / input
+        return None
 
     @property
-    def indoor_unit_water_pump_state(self):
+    def indoor_unit_water_pump_state(self) -> Union[bool, None]:
         """Decoded water pump state."""
         return self._if_available("control_bridge_status_decoded_water_pump")
 
     @property
-    def indoor_unit_auxiliary_pump_state(self):
+    def indoor_unit_auxiliary_pump_state(self) -> Union[bool, None]:
         """Decoded auxiliary pump state."""
         return self._if_available("control_bridge_status_decoded_water_pump2")
 
     @property
-    def indoor_unit_dhw_valve_or_pump_state(self):
+    def indoor_unit_dhw_valve_or_pump_state(self) -> Union[bool, None]:
         """Decoded DHW valve or pump state."""
         return self._if_available("control_bridge_status_decoded_dhw_valve")
 
     @property
-    def indoor_unit_gas_boiler_state(self):
+    def indoor_unit_gas_boiler_state(self) -> Union[bool, None]:
         """Decoded gas boiler state."""
         return self._if_available("control_bridge_status_decoded_gas_boiler")
 
     @property
-    def indoor_unit_electric_heater_state(self):
+    def indoor_unit_electric_heater_state(self) -> Union[bool, None]:
         """Decoded electric heater state."""
         return self._if_available("control_bridge_status_decoded_electric_heater")
 
     @property
-    def compressor_percentage(self):
+    def compressor_percentage(self) -> Union[int, None]:
         current_rpm = self._if_available("rpm")
         if self._nominal_max_power is not None and current_rpm is not None:
             # calculate percentage of rpm
@@ -229,12 +256,12 @@ class HeatPump:
         return None
 
     @property
-    def compressor_rpm(self):
+    def compressor_rpm(self) -> Union[float, None]:
         """Compressor RPM."""
         return self._if_available("rpm")
 
     @property
-    def heat_pump_state(self) -> State | None:
+    def heat_pump_state(self) -> Union[State, None]:
         """The heat pump state."""
         numeric_state = self._if_available("state")
         if numeric_state is None:
@@ -259,11 +286,11 @@ class HeatPump:
         return None
 
     @property
-    def energy_total(self):
+    def energy_total(self) -> Union[float, None]:
         """The total used energy in kWh from 2023 to now."""
         return self._energy_consumption
 
     @property
-    def energy_output(self):
+    def energy_output(self) -> Union[float, None]:
         """The total energy output in kWh from 2023 to now."""
         return self._energy_output

weheat/abstractions/user.py

@@ -1,4 +1,5 @@
 import asyncio
+from typing import Union
 
 import aiohttp
 
@@ -7,17 +8,16 @@ from weheat.api_client import ApiClient
 from weheat.api.user_api import UserApi
 
 
-async def async_get_user_id_from_token(api_url: str, access_token: str, client_session:aiohttp.ClientSession|None = None):
+async def async_get_user_id_from_token(api_url: str, access_token: str, client_session:aiohttp.ClientSession|None = None) -> Union[str,None]:
     """ Get the user id from the current logged-in user. """
-    try:
-        config = Configuration(host=api_url, access_token=access_token, client_session=client_session)
+    config = Configuration(host=api_url, access_token=access_token, client_session=client_session)
 
-        async with ApiClient(configuration=config) as client:
-            response = await UserApi(
-                client
-            ).api_v1_users_me_get_with_http_info()
+    async with ApiClient(configuration=config) as client:
+        response = await UserApi(
+            client
+        ).api_v1_users_me_get_with_http_info()
+
+        if response.status_code == 200:
+            return response.data.id # type: ignore[no-any-return]
+        return None
 
-            if response.status_code == 200:
-                return response.data.id
-    except Exception as e:
-        raise e

weheat/exceptions.py

@@ -105,9 +105,9 @@ class ApiKeyError(OpenApiException, KeyError):
 class ApiException(OpenApiException):
 
     def __init__(
-        self, 
-        status=None, 
-        reason=None, 
+        self,
+        status=None,
+        reason=None,
         http_resp=None,
         *,
         body: Optional[str] = None,
@@ -133,10 +133,10 @@ class ApiException(OpenApiException):
 
     @classmethod
     def from_response(
-        cls, 
-        *, 
-        http_resp, 
-        body: Optional[str], 
+        cls,
+        *,
+        http_resp,
+        body: Optional[str],
         data: Optional[Any],
     ) -> Self:
         if http_resp.status == 400:
@@ -151,6 +151,9 @@ class ApiException(OpenApiException):
         if http_resp.status == 404:
             raise NotFoundException(http_resp=http_resp, body=body, data=data)
 
+        if http_resp.status == 429:
+            raise TooManyRequestsException(http_resp=http_resp, body=body, data=data)
+
         if 500 <= http_resp.status <= 599:
             raise ServiceException(http_resp=http_resp, body=body, data=data)
         raise ApiException(http_resp=http_resp, body=body, data=data)
@@ -189,6 +192,10 @@ class ServiceException(ApiException):
     pass
 
 
+class TooManyRequestsException(ApiException):
+    pass
+
+
 def render_path(path_to_item):
     """Returns a string representation of a path"""
     result = ""

{weheat-2025.1.15rc2.dist-info → weheat-2025.2.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: weheat
-Version: 2025.1.15rc2
+Version: 2025.2.22
 Summary: Weheat Backend client
 Home-page: https://github.com/wefabricate/wh-python
 Author: Jesper Raemaekers

{weheat-2025.1.15rc2.dist-info → weheat-2025.2.22.dist-info}/RECORD

@@ -2,14 +2,13 @@ weheat/__init__.py,sha256=C24j_uAbbyEzqh8DmQyORUrVMdFDlzEv4jGClf4TY34,1765
 weheat/api_client.py,sha256=Bh5xHchRGCcsHbT3rXrcmhKCMiumi1_2L6n0Q57KODw,24803
 weheat/api_response.py,sha256=A7O_XgliD6y7jEv82fgIaxR3T8KiwaOqHR6djpZyh_o,674
 weheat/configuration.py,sha256=8D0zAgx7B6YmVNuyS0AarcCAl5TmKKH655jHqWrvSl0,14531
-weheat/exceptions.py,sha256=jZjLtEMBKFpLTdV1GPsbQSPriG1ilgMSodGnhEKlWh4,5913
+weheat/exceptions.py,sha256=Wbn9RsKWzTJHpp5sllYbMjqMWMc8ZyFm_J2sfptVG7g,6086
 weheat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 weheat/rest.py,sha256=hSt8T6NQfdrgz_7Dxo9U-DO5ZEgUVVG38OUErThWqlU,7086
-weheat/abstractions/__init__.py,sha256=cRdA_kyTIooo39I13_mqShSfZMqdzNGHbmrnITqgx6A,161
-weheat/abstractions/auth.py,sha256=VCAxJ4OIj7bsYttqJl5-juU0VUlSd3xPu7kUjtHZr3U,979
+weheat/abstractions/__init__.py,sha256=BbA5WW8RE8vtpK0Dq80ayMILN4m6lmCyIPYzYXy3rTE,177
 weheat/abstractions/discovery.py,sha256=PrhyM29OKvCgKzWig5BAjaEF15CIcTp_AIBZg2lyJ6Y,2384
-weheat/abstractions/heat_pump.py,sha256=DFgKF_4Mdv4dOVugECy9xB4y6e85B-HwZatrUBSnhPE,9920
-weheat/abstractions/user.py,sha256=L48CGvBe7YrUa-wnIgmv9Hu0DOMN4IXN0fSmufrlJIc,760
+weheat/abstractions/heat_pump.py,sha256=roUDxZZsKTbTmI9ZJqXKy51IoMlyJGY5N1tqSl8TIv8,11322
+weheat/abstractions/user.py,sha256=moeJAmbjdYuXAkL7Xuks5w4zcPpjKUXM9nYJDv8WEXs,775
 weheat/api/__init__.py,sha256=zZ_Xqek8VY6gARsJK6hRess0qqGii-Ls1uXm92k0jPE,244
 weheat/api/energy_log_api.py,sha256=plZ9YoQ9O39qufzr3B6CduuzJMY1K6iJS5f5AXN-vUo,17587
 weheat/api/heat_pump_api.py,sha256=tyFA-Xf-Ld4cAVSYblCq1s5I1CDRQmKJx9UBJivnS0Y,28211
@@ -30,8 +29,8 @@ weheat/models/read_heat_pump_dto.py,sha256=7jH2MwMVKv_dOoJUUsKE8sTR5mROqco71OzOA
 weheat/models/read_user_dto.py,sha256=OIsWQZcdByN94ViSv0DjFHORRsMnkQ93jc-gJuudRdg,4018
 weheat/models/read_user_me_dto.py,sha256=Ger6qKlbZBBvG_4MStl6aEMkrBBJIjQtV6pvK1-lw28,4441
 weheat/models/role.py,sha256=6KUInAmkhoxEdWxBo9jBHXiy_nqJHrKXVeh8RvQPEYM,1101
-weheat-2025.1.15rc2.dist-info/LICENSE,sha256=rWmFUq0uth2jpet-RQ2QPd2VhZkcPSUs6Dxfmbqkbis,1068
-weheat-2025.1.15rc2.dist-info/METADATA,sha256=lg2CZbj2OGdxFi33MKKI7VrqKmvlBc-Uvf1IIeO3wvA,3877
-weheat-2025.1.15rc2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-weheat-2025.1.15rc2.dist-info/top_level.txt,sha256=hLzdyvGZ9rs4AqK7U48mdHx_-FcP5sDuTSleDUvGAZw,7
-weheat-2025.1.15rc2.dist-info/RECORD,,
+weheat-2025.2.22.dist-info/LICENSE,sha256=rWmFUq0uth2jpet-RQ2QPd2VhZkcPSUs6Dxfmbqkbis,1068
+weheat-2025.2.22.dist-info/METADATA,sha256=5rEYpRYuupCQjYhY8pK7KICJ60DTBrQQL3V2Oi5zBkU,3874
+weheat-2025.2.22.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+weheat-2025.2.22.dist-info/top_level.txt,sha256=hLzdyvGZ9rs4AqK7U48mdHx_-FcP5sDuTSleDUvGAZw,7
+weheat-2025.2.22.dist-info/RECORD,,

weheat/abstractions/auth.py

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