weheat 2024.11.1__py3-none-any.whl → 2025.11.24rc1__py3-none-any.whl

weheat/__init__.py

@@ -14,7 +14,7 @@
 """  # noqa: E501
 
 
-__version__ = "2024.07.08"
+__version__ = "2025.11.24"
 
 # import apis into sdk package
 from weheat.api.energy_log_api import EnergyLogApi
@@ -34,12 +34,16 @@ from weheat.exceptions import ApiAttributeError
 from weheat.exceptions import ApiException
 
 # import models into sdk package
+from weheat.models.boiler_type import BoilerType
 from weheat.models.device_state import DeviceState
+from weheat.models.dhw_type import DhwType
 from weheat.models.energy_view_dto import EnergyViewDto
 from weheat.models.heat_pump_log_view_dto import HeatPumpLogViewDto
+from weheat.models.heat_pump_model import HeatPumpModel
+from weheat.models.heat_pump_status_enum import HeatPumpStatusEnum
 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
 from weheat.models.read_user_dto import ReadUserDto
+from weheat.models.read_user_me_dto import ReadUserMeDto
 from weheat.models.role import Role
-

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/discovery.py

@@ -1,5 +1,8 @@
+import asyncio
 from dataclasses import dataclass
 
+import aiohttp
+
 from weheat import DeviceState
 from weheat.configuration import Configuration
 from weheat.api_client import ApiClient
@@ -10,22 +13,23 @@ class HeatPumpDiscovery:
     @dataclass
     class HeatPumpInfo:
         uuid: str
-        name: str
+        device_name: str
         model: str
         sn : str
         has_dhw: bool = False
 
     @staticmethod
-    async def discover_active(api_url: str, access_token: str) -> list[HeatPumpInfo]:
+    async def async_discover_active(api_url: str, access_token: str, client_session:aiohttp.ClientSession|None = None) -> list[HeatPumpInfo]:
         discovered_pumps = []
 
-        config = Configuration(host=api_url, access_token=access_token)
+        config = Configuration(host=api_url, access_token=access_token, client_session=client_session)
+
+        async with ApiClient(configuration=config) as client:
 
-        with ApiClient(configuration=config) as client:
+            response = await  HeatPumpApi(client).api_v1_heat_pumps_get_with_http_info(1, 1000, state=DeviceState.NUMBER_3)
 
-            response = HeatPumpApi(client).api_v1_heat_pumps_get_with_http_info('', 0, 1000, DeviceState.NUMBER_3 ,async_req=True).get()
             if response.status_code == 200:
-                for pump in response.data:
+                for pump in response.data.data:
                     # Model of the heat pump
                     # - BlackBirdP80: BlackBird P80 heat pump (0)
                     # - BlackBirdP60: BlackBird P60 heat pump (1)
@@ -49,7 +53,7 @@ class HeatPumpDiscovery:
                     discovered_pumps.append(
                         HeatPumpDiscovery.HeatPumpInfo(
                             uuid=pump.id,
-                            name=pump.name,
+                            device_name=pump.name,
                             model=model_string,
                             sn=pump.serial_number,
                             has_dhw=dhw,

weheat/abstractions/heat_pump.py

@@ -1,19 +1,28 @@
 """Weheat heat pump abstraction from the API."""
+import asyncio
 from enum import Enum, auto
 
+import aiohttp
+
 from weheat import HeatPumpApi
 from weheat.configuration import Configuration
 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
+
+from weheat.models import TotalEnergyAggregate
 
 # 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()
@@ -25,162 +34,172 @@ class HeatPump:
         SELF_TEST = auto()
         MANUAL_CONTROL = auto()
 
-    def __init__(self, api_url: str, uuid: str) -> 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_total: Union[TotalEnergyAggregate, None] = None
+        self._nominal_max_power: Union[float, None] = None
+        self._client = client_session
 
-    def 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)
+            config = Configuration(host=self._api_url, access_token=access_token, client_session=self._client)
 
-            with ApiClient(configuration=config) as client:
+            async with ApiClient(configuration=config) as client:
                 # Set the max power once
                 if self._nominal_max_power is None:
-                    repsonse = 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 repsonse.status_code == 200:
-                        self._set_nominal_max_power_for_model(repsonse.data.model)
+                    if response.status_code == 200:
+                        self._set_nominal_max_power_for_model(response.data.model)
 
-
-                response = HeatPumpLogApi(
+                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
 
-                # 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 = 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='Year')
 
-                if response.status_code == 200:
-                    # aggregate the energy consumption
-                    self._energy_consumption = 0
-                    self._energy_output = 0
-                    for year in response.data:
-                        self._energy_consumption += year.total_ein_cooling
-                        self._energy_consumption += year.total_ein_heating
-                        self._energy_consumption += year.total_ein_heating_defrost
-                        self._energy_consumption += year.total_ein_dhw
-                        self._energy_consumption += year.total_ein_dhw_defrost
-                        self._energy_output += year.total_e_out_cooling
-                        self._energy_output += year.total_e_out_heating
-                        self._energy_output += year.total_e_out_heating_defrost
-                        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
+            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:
+                response = await EnergyLogApi(client).total_heat_pump_id_get_with_http_info(heat_pump_id=self._uuid)
+
+                if response.status_code == 200:
+                    # aggregate the energy consumption
+                    self._energy_total = response.data
 
         except Exception as e:
-            self._last_log = None
-            self._energy_consumption = None
-            raise e
+            self._energy_total = None
+
+    def _if_available_and_valid(self, key:str) -> Optional[T]:
+        """Return the value from the last logged value if available and not -1. None otherwise."""
+        value = self._if_available(key)
+        if value is not None and value != -1:
+            return value
+        return 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
-            self._nominal_max_power = 5280
+            # BB60
+            self._nominal_max_power = 5520
         elif 2 <= model_id <= 4:
-            #SP60
-            self._nominal_max_power = 5280
+            # SP60
+            self._nominal_max_power = 5520
         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")
+        return self._if_available_and_valid("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")
+        return self._if_available_and_valid("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
@@ -188,36 +207,42 @@ class HeatPump:
         """
         input = self.power_input
         output = self.power_output
-        if input is not None and output is not None and input != 0:
+        # When either is not available, the calculation cannot be made.
+        if input is None or output is None:
+            return None
+
+        if input > 0:
             return output / input
 
+        return 0
+
     @property
-    def inside_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 inside_unit_auxilary_pump_state(self):
-        """Decoded auxilary pump state."""
+    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 inside_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 inside_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 inside_unit_gas_electric_heater(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
@@ -225,12 +250,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:
@@ -240,7 +265,7 @@ class HeatPump:
             return self.State.STANDBY
         elif numeric_state == 70:
             return self.State.HEATING
-        elif numeric_state == 130:
+        elif numeric_state >= 130 and numeric_state < 140:
             return self.State.COOLING
         elif numeric_state == 150:
             return self.State.DHW
@@ -250,16 +275,133 @@ class HeatPump:
             return self.State.SELF_TEST
         elif numeric_state == 180:
             return self.State.MANUAL_CONTROL
-        elif numeric_state == 200:
+        elif numeric_state >= 200 and numeric_state <= 240:
             return self.State.DEFROSTING
         return None
 
+    @staticmethod
+    def _pwm_to_volume(pwm: float, max: float) -> Union[float, None]:
+        """Calculate PWM to Volume in m3/h based on the max available volume"""
+
+        # 0 or > 75 are abnormal states. 255 = Off
+        if pwm < 1 or pwm > 75:
+            return None
+
+        # 2 = standby
+        if pwm <= 5:
+            return 0
+
+        # 5-75 is linear from 0 to max
+        return ((pwm - 5) / 70) * max
+    
     @property
-    def energy_total(self):
-        """The total used energy in kWh from 2023 to now."""
-        return self._energy_consumption
+    def dhw_flow_volume(self) -> Union[float, None]:
+        """The DHW Flow in m3/h."""
+        pwm = pwm=self._if_available("dhw_flow")
+        if pwm is None:
+            return None
+        
+        return self._pwm_to_volume(pwm, max=2.1)
+
+    @property
+    def central_heating_flow_volume(self) -> Union[float, None]:
+        """The Central Heating Flow in m3/h."""
+        pwm = pwm=self._if_available("central_heating_flow")
+        if pwm is None:
+            return None
+        
+        return self._pwm_to_volume(pwm, max=2.1)
+    
+    @property
+    def energy_in_heating(self) -> Union[float, None]:
+        """The total used energy in heating mode."""
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_ein_heating)
 
     @property
-    def energy_output(self):
-        """The total energy output in kWh from 2023 to now."""
-        return self._energy_output
+    def energy_in_dhw(self) -> Union[float, None]:
+        """The total used energy in DHW mode."""
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_ein_dhw)
+
+    @property
+    def energy_in_defrost(self) -> Union[float, None]:
+        """The total used energy in defrost modes."""
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_ein_heating_defrost + self._energy_total.total_ein_dhw_defrost)
+
+    @property
+    def energy_in_defrost_dhw(self) -> Union[float, None]:
+        """The total used energy in defrost from DHW mode."""
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_ein_dhw_defrost)
+
+    @property
+    def energy_in_defrost_ch(self) -> Union[float, None]:
+        """The total used energy in defrost from CH mode."""
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_ein_heating_defrost)
+
+    @property
+    def energy_in_cooling(self) -> Union[float, None]:
+        """The total used energy in cooling mode."""
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_ein_cooling)
+
+    @property
+    def energy_out_heating(self) -> Union[float, None]:
+        """The total supplied energy in heating mode."""
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_e_out_heating)
+
+
+    @property
+    def energy_out_dhw(self) -> Union[float, None]:
+        """The total supplied energy in DHW mode."""
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_e_out_dhw)
+
+    @property
+    def energy_out_defrost(self) -> Union[float, None]:
+        """The total supplied energy in defrost modes.
+        Note that this energy value is negative as energy is removed from the water.
+        """
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_e_out_dhw_defrost + self._energy_total.total_e_out_heating_defrost)
+
+    @property
+    def energy_out_defrost_dhw(self) -> Union[float, None]:
+        """The total supplied energy in defrost DHW mode.
+        Note that this energy value is negative as energy is removed from the water.
+        """
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_e_out_dhw_defrost)
+
+
+    @property
+    def energy_out_defrost_ch(self) -> Union[float, None]:
+        """The total supplied energy in defrost CH mode.
+        Note that this energy value is negative as energy is removed from the water.
+        """
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_e_out_heating_defrost)
+
+    @property
+    def energy_out_cooling(self) -> Union[float, None]:
+        """The total supplied energy in cooling mode.
+        Note that this energy value is negative as energy is removed from the water.
+        """
+        if self._energy_total is None:
+            return None
+        return float(self._energy_total.total_e_out_cooling)

weheat/abstractions/user.py

@@ -1,18 +1,23 @@
+import asyncio
+from typing import Union
+
+import aiohttp
+
 from weheat.configuration import Configuration
 from weheat.api_client import ApiClient
 from weheat.api.user_api import UserApi
 
 
-async def get_user_id_from_token(api_url: str, access_token: str):
+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)
+    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()
+
+        if response.status_code == 200:
+            return response.data.id # type: ignore[no-any-return]
+        return None
 
-        with ApiClient(configuration=config) as client:
-            response = UserApi(
-                client
-            ).api_v1_users_me_get_with_http_info(async_req=True).get()
-            if response.status_code == 200:
-                return response.data.id
-    except Exception as e:
-        raise e

weheat/api/__init__.py

@@ -5,3 +5,4 @@ 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
 from weheat.api.user_api import UserApi
+