weheat 2025.1.15rc1__py3-none-any.whl → 2025.2.13__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/discovery.py

@@ -1,6 +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
@@ -17,10 +19,10 @@ class HeatPumpDiscovery:
         has_dhw: bool = False
 
     @staticmethod
-    async def async_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:
 

weheat/abstractions/heat_pump.py

@@ -2,19 +2,25 @@
 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
 
 # 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()
@@ -26,42 +32,62 @@ 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_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)
+            config = Configuration(host=self._api_url, access_token=access_token, client_session=self._client)
 
             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
@@ -79,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
@@ -191,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
@@ -226,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:
@@ -256,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,21 +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 async_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()
 
-        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/configuration.py

@@ -15,6 +15,8 @@
 import copy
 import logging
 import sys
+
+import aiohttp
 import urllib3
 
 import http.client as httplib
@@ -51,6 +53,7 @@ class Configuration:
       values before.
     :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
       in PEM format.
+    : param client_session: A aiohttp.ClientSession to use
 
     :Example:
     """
@@ -63,7 +66,7 @@ class Configuration:
                  access_token=None,
                  server_index=None, server_variables=None,
                  server_operation_index=None, server_operation_variables=None,
-                 ssl_ca_cert=None,
+                 ssl_ca_cert=None, client_session=None
                  ) -> None:
         """Constructor
         """
@@ -179,6 +182,8 @@ class Configuration:
         """date format
         """
 
+        self._client_session = client_session
+
     def __deepcopy__(self, memo):
         cls = self.__class__
         result = cls.__new__(cls)
@@ -196,6 +201,10 @@ class Configuration:
     def __setattr__(self, name, value):
         object.__setattr__(self, name, value)
 
+    @property
+    def client_session(self) -> aiohttp.ClientSession|None:
+        return self._client_session
+
     @classmethod
     def set_default(cls, default):
         """Set default instance of configuration.

weheat/rest.py

@@ -55,32 +55,37 @@ class RESTClientObject:
         # maxsize is number of requests to host that are allowed in parallel
         maxsize = configuration.connection_pool_maxsize
 
-        ssl_context = ssl.create_default_context(
-            cafile=configuration.ssl_ca_cert
-        )
-        if configuration.cert_file:
-            ssl_context.load_cert_chain(
-                configuration.cert_file, keyfile=configuration.key_file
+        self._client_session = configuration.client_session
+        # only setup SSL when the session is not provided. Otherwise, it will do disk access and HA will get mad.
+        if not configuration.client_session:
+            ssl_context = ssl.create_default_context(
+                cafile=configuration.ssl_ca_cert
             )
+            if configuration.cert_file:
+                ssl_context.load_cert_chain(
+                    configuration.cert_file, keyfile=configuration.key_file
+                )
+
+            if not configuration.verify_ssl:
+                ssl_context.check_hostname = False
+                ssl_context.verify_mode = ssl.CERT_NONE
 
-        if not configuration.verify_ssl:
-            ssl_context.check_hostname = False
-            ssl_context.verify_mode = ssl.CERT_NONE
+            connector = aiohttp.TCPConnector(
+                limit=maxsize,
+                ssl=ssl_context
+            )
 
-        connector = aiohttp.TCPConnector(
-            limit=maxsize,
-            ssl=ssl_context
-        )
+            # https pool manager
+            self.pool_manager = aiohttp.ClientSession(
+                connector=connector,
+                trust_env=True
+            )
+        else:
+            self.pool_manager = configuration.client_session
 
         self.proxy = configuration.proxy
         self.proxy_headers = configuration.proxy_headers
 
-        # https pool manager
-        self.pool_manager = aiohttp.ClientSession(
-            connector=connector,
-            trust_env=True
-        )
-
         retries = configuration.retries
         if retries is not None:
             self.retry_client = aiohttp_retry.RetryClient(
@@ -96,6 +101,9 @@ class RESTClientObject:
             self.retry_client = None
 
     async def close(self):
+        # do not close the session if provided via client_session
+        if self._client_session:
+            return
         await self.pool_manager.close()
         if self.retry_client is not None:
             await self.retry_client.close()

{weheat-2025.1.15rc1.dist-info → weheat-2025.2.13.dist-info}/METADATA

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

{weheat-2025.1.15rc1.dist-info → weheat-2025.2.13.dist-info}/RECORD

@@ -1,15 +1,14 @@
 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=bSjeNWmg5SuxyULRbUR9KCuPK9yHSYCbrZlIbY6UiAo,14278
+weheat/configuration.py,sha256=8D0zAgx7B6YmVNuyS0AarcCAl5TmKKH655jHqWrvSl0,14531
 weheat/exceptions.py,sha256=jZjLtEMBKFpLTdV1GPsbQSPriG1ilgMSodGnhEKlWh4,5913
 weheat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-weheat/rest.py,sha256=r0ot19pStSTb4Nwco98UeSsppIQAR8FxQecABO4y9aY,6598
-weheat/abstractions/__init__.py,sha256=cRdA_kyTIooo39I13_mqShSfZMqdzNGHbmrnITqgx6A,161
-weheat/abstractions/auth.py,sha256=VCAxJ4OIj7bsYttqJl5-juU0VUlSd3xPu7kUjtHZr3U,979
-weheat/abstractions/discovery.py,sha256=Z1_tLFJzZkbA8CYIs2KpxoMB7S6Xc-V8jRk-LQeX1UE,2287
-weheat/abstractions/heat_pump.py,sha256=MwOXkUSJaq820clvM-iYaeMmYn4YfR7k6ML3pPR5nbY,9787
-weheat/abstractions/user.py,sha256=gQ5hSthG7c434lqsliI91uBOIkUQ8uTdRmCV-e7Y_Gk,663
+weheat/rest.py,sha256=hSt8T6NQfdrgz_7Dxo9U-DO5ZEgUVVG38OUErThWqlU,7086
+weheat/abstractions/__init__.py,sha256=BbA5WW8RE8vtpK0Dq80ayMILN4m6lmCyIPYzYXy3rTE,177
+weheat/abstractions/discovery.py,sha256=PrhyM29OKvCgKzWig5BAjaEF15CIcTp_AIBZg2lyJ6Y,2384
+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.15rc1.dist-info/LICENSE,sha256=rWmFUq0uth2jpet-RQ2QPd2VhZkcPSUs6Dxfmbqkbis,1068
-weheat-2025.1.15rc1.dist-info/METADATA,sha256=6-x-xTzWRV5bFUC4lUNjN1PULmzeH7IpHtnsHu3F8cM,3877
-weheat-2025.1.15rc1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-weheat-2025.1.15rc1.dist-info/top_level.txt,sha256=hLzdyvGZ9rs4AqK7U48mdHx_-FcP5sDuTSleDUvGAZw,7
-weheat-2025.1.15rc1.dist-info/RECORD,,
+weheat-2025.2.13.dist-info/LICENSE,sha256=rWmFUq0uth2jpet-RQ2QPd2VhZkcPSUs6Dxfmbqkbis,1068
+weheat-2025.2.13.dist-info/METADATA,sha256=0bLyZ1P3cZCQ18fR8tKgh_FkB1jbaMcZw90bCSkIhPk,3874
+weheat-2025.2.13.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+weheat-2025.2.13.dist-info/top_level.txt,sha256=hLzdyvGZ9rs4AqK7U48mdHx_-FcP5sDuTSleDUvGAZw,7
+weheat-2025.2.13.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,
-        )