PyViCare 2.60.2__tar.gz → 2.61.0__tar.gz

{pyvicare-2.60.2 → pyvicare-2.61.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyViCare
-Version: 2.60.2
+Version: 2.61.0
 Summary: Library to communicate with the Viessmann ViCare API.
 License: Apache-2.0
 License-File: LICENSE

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCare.py

@@ -4,10 +4,11 @@ from datetime import datetime
 from PyViCare.PyViCareAbstractOAuthManager import AbstractViCareOAuthManager
 from PyViCare.PyViCareBrowserOAuthManager import ViCareBrowserOAuthManager
 from PyViCare.PyViCareCachedService import ViCareCachedService
+from PyViCare.PyViCareCachedServiceViaGateway import ViCareCachedServiceViaGateway
 from PyViCare.PyViCareDeviceConfig import PyViCareDeviceConfig
 from PyViCare.PyViCareOAuthManager import ViCareOAuthManager
-from PyViCare.PyViCareRoomControl import RoomControl
 from PyViCare.PyViCareService import ViCareDeviceAccessor, ViCareService
+from PyViCare.PyViCareServiceViaGateway import ViCareServiceViaGateway
 from PyViCare.PyViCareUtils import PyViCareInvalidDataError
 
 logger = logging.getLogger(__name__)
@@ -16,12 +17,25 @@ logger.addHandler(logging.NullHandler())
 
 class PyViCare:
     """"Viessmann ViCare API Python tools"""
+    viaGateway = False
+
     def __init__(self) -> None:
         self.cacheDuration = 60
 
     def setCacheDuration(self, cache_duration):
         self.cacheDuration = int(cache_duration)
 
+    def loadViaGateway(self, via_gateway: bool = True) -> None:
+        """Opt in to per-gateway bulk fetching.
+
+        When enabled, ONE service instance per gateway serves all devices on
+        that gateway via the bulk endpoint
+        `/features/installations/{id}/gateways/{serial}/features?includeDevicesFeatures=true`,
+        instead of one HTTP call per device per refresh. Must be called
+        before initWith* (services are wired during __loadInstallations).
+        """
+        self.viaGateway = via_gateway
+
     def initWithCredentials(self, username: str, password: str, client_id: str, token_file: str):
         self.initWithExternalOAuth(ViCareOAuthManager(
             username, password, client_id, token_file))
@@ -33,10 +47,15 @@ class PyViCare:
     def initWithBrowserOAuth(self, client_id: str, token_file: str) -> None:
         self.initWithExternalOAuth(ViCareBrowserOAuthManager(client_id, token_file))
 
-    def __buildService(self, accessor, roles):
+    def __buildService(self, roles):
         if self.cacheDuration > 0:
-            return ViCareCachedService(self.oauth_manager, accessor, roles, self.cacheDuration)
-        return ViCareService(self.oauth_manager, accessor, roles)
+            return ViCareCachedService(self.oauth_manager, roles, self.cacheDuration)
+        return ViCareService(self.oauth_manager, roles)
+
+    def __buildGatewayService(self):
+        if self.cacheDuration > 0:
+            return ViCareCachedServiceViaGateway(self.oauth_manager, self.cacheDuration)
+        return ViCareServiceViaGateway(self.oauth_manager)
 
     def __loadInstallations(self):
         installations = self.oauth_manager.get(
@@ -50,7 +69,6 @@ class PyViCare:
         self.all_devices = list(self.__extract_all_devices())
         self.devices = [d for d in self.all_devices
                         if d.device_type in self.SUPPORTED_DEVICE_TYPES]
-        self.__enrichZigbeeDevices()
 
     SUPPORTED_DEVICE_TYPES = [
         "heating", "zigbee", "vitoconnect", "electricityStorage",
@@ -60,43 +78,15 @@ class PyViCare:
     def __extract_all_devices(self):
         for installation in self.installations:
             for gateway in installation.gateways:
+                shared_service = self.__buildGatewayService() if self.viaGateway else None
                 for device in gateway.devices:
                     accessor = ViCareDeviceAccessor(
                         installation.id, gateway.serial, device.id)
-                    service = self.__buildService(accessor, device.roles)
+                    service = shared_service if shared_service is not None else self.__buildService(device.roles)
 
                     logger.info("Device found: %s (type=%s)", device.modelId, device.deviceType)
 
-                    yield PyViCareDeviceConfig(service, device.id, device.modelId, device.status, device.deviceType, device.roles)
-
-    def __enrichZigbeeDevices(self):
-        """Enrich Zigbee devices with sensor data from RoomControl.
-
-        Viessmann moved temperature/humidity data from physical Zigbee
-        sensors to the RoomControl virtual device. This reverses that
-        mapping by cross-referencing RoomControl actors with Zigbee
-        device IDs.
-        """
-        devices_by_id = {device_config.device_id: device_config for device_config in self.devices}
-
-        for device_config in self.devices:
-            if device_config.device_type != "roomControl":
-                continue
-
-            room_control = RoomControl(device_config.service)
-            try:
-                actor_map = room_control.buildActorRoomMap()
-            except Exception:  # pylint: disable=broad-exception-caught
-                logger.debug("Could not build actor map for %s", device_config.getModel(), exc_info=True)
-                continue
-
-            for device_id, room_id in actor_map.items():
-                zigbee_config = devices_by_id.get(device_id)
-                if zigbee_config is None:
-                    continue
-                zigbee_config.setRoomControlEnrichment(room_control, room_id)
-                logger.info("Enriched %s with room %s data from %s",
-                            zigbee_config.device_id, room_id, device_config.getModel())
+                    yield PyViCareDeviceConfig(accessor, service, device.modelId, device.status, device.deviceType, device.roles)
 
 
 class DictWrap(object):

pyvicare-2.61.0/PyViCare/PyViCareCachedService.py

@@ -0,0 +1,23 @@
+import logging
+from typing import Any, List
+
+from PyViCare.PyViCareAbstractOAuthManager import AbstractViCareOAuthManager
+from PyViCare.PyViCareCachedServiceBase import ViCareCachedServiceBase
+from PyViCare.PyViCareService import ViCareDeviceAccessor, ViCareService
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class ViCareCachedService(ViCareCachedServiceBase, ViCareService):
+
+    def __init__(self, oauth_manager: AbstractViCareOAuthManager, roles: List[str], cacheDuration: int) -> None:
+        ViCareService.__init__(self, oauth_manager, roles)
+        self._init_cache(cacheDuration)
+
+    def _fetch_uncached(self, accessor: ViCareDeviceAccessor) -> Any:
+        return ViCareService.fetch_all_features(self, accessor)
+
+    def _extract_entities(self, data: dict, accessor: ViCareDeviceAccessor) -> list[dict[str, Any]]:
+        entities: list[dict[str, Any]] = data["data"]
+        return entities

pyvicare-2.61.0/PyViCare/PyViCareCachedServiceBase.py

@@ -0,0 +1,82 @@
+import logging
+import threading
+from datetime import datetime
+from typing import Any, Optional
+
+from PyViCare.PyViCareService import (ViCareDeviceAccessor, ViCareService,
+                                      readFeature)
+from PyViCare.PyViCareUtils import (PyViCareDeviceCommunicationError,
+                                    PyViCareInternalServerError,
+                                    PyViCareInvalidDataError,
+                                    PyViCareNotPaidForError,
+                                    PyViCareNotSupportedFeatureError,
+                                    ViCareTimer)
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class ViCareCachedServiceBase(ViCareService):
+    """Time-based caching shared by the per-device and per-gateway services.
+
+    Subclasses provide `_fetch_uncached` (the HTTP fetch) and `_extract_entities`
+    (pick this device's features out of the cached payload).
+    """
+
+    def _init_cache(self, cacheDuration: int) -> None:
+        self._cacheDuration = cacheDuration
+        self._cache: Optional[dict] = None
+        self._cacheTime: Optional[datetime] = None
+        self._cacheLock = threading.Lock()
+
+    def getProperty(self, accessor: ViCareDeviceAccessor, property_name: str) -> Any:
+        data = self._get_or_update_cache(accessor)
+        entities = self._extract_entities(data, accessor)
+        return readFeature(entities, property_name)
+
+    def setProperty(self, accessor: ViCareDeviceAccessor, property_name: str, action: str, data: Any) -> Any:
+        response = super().setProperty(accessor, property_name, action, data)
+        self.clear_cache()
+        return response
+
+    def _get_or_update_cache(self, accessor: ViCareDeviceAccessor):
+        with self._cacheLock:
+            if self.is_cache_invalid():
+                # we always set the cache time before we fetch the data
+                # to avoid consuming all the api calls if the api is down
+                # see https://github.com/home-assistant/core/issues/67052
+                # we simply return the old cache in this case
+                self._cacheTime = ViCareTimer().now()
+
+                try:
+                    data = self._fetch_uncached(accessor)
+                except PyViCareNotPaidForError as e:
+                    logger.error("Viessmann API denied access (PACKAGE_NOT_PAID_FOR). Features unavailable: %s", e)
+                    if self._cache is not None:
+                        return self._cache
+                    raise PyViCareNotSupportedFeatureError("PACKAGE_NOT_PAID_FOR")
+                except (PyViCareDeviceCommunicationError, PyViCareInternalServerError) as e:
+                    if self._cache is not None:
+                        logger.warning("API error, returning stale cache: %s", e)
+                        return self._cache
+                    raise
+
+                if "data" not in data:
+                    logger.error("Missing 'data' property when fetching data.")
+                    raise PyViCareInvalidDataError(data)
+                self._cache = data
+            return self._cache
+
+    def is_cache_invalid(self) -> bool:
+        return self._cache is None or self._cacheTime is None or (ViCareTimer().now() - self._cacheTime).seconds > self._cacheDuration
+
+    def clear_cache(self):
+        with self._cacheLock:
+            self._cache = None
+            self._cacheTime = None
+
+    def _fetch_uncached(self, accessor: ViCareDeviceAccessor) -> Any:
+        raise NotImplementedError
+
+    def _extract_entities(self, data: dict, accessor: ViCareDeviceAccessor) -> list[dict[str, Any]]:
+        raise NotImplementedError

pyvicare-2.61.0/PyViCare/PyViCareCachedServiceViaGateway.py

@@ -0,0 +1,34 @@
+import logging
+from typing import Any
+
+from PyViCare.PyViCareAbstractOAuthManager import AbstractViCareOAuthManager
+from PyViCare.PyViCareCachedServiceBase import ViCareCachedServiceBase
+from PyViCare.PyViCareService import ViCareDeviceAccessor
+from PyViCare.PyViCareServiceViaGateway import (
+    ViCareServiceViaGateway, filter_features_for_device)
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class ViCareCachedServiceViaGateway(ViCareCachedServiceBase, ViCareServiceViaGateway):
+    """Cached variant of the gateway bulk-fetch service.
+
+    One instance is shared across all devices on the gateway; every device's
+    getProperty reads from the same cached bulk payload. setProperty clears the
+    whole cache.
+    """
+
+    def __init__(self, oauth_manager: AbstractViCareOAuthManager, cacheDuration: int) -> None:  # pylint: disable=super-init-not-called
+        ViCareServiceViaGateway.__init__(self, oauth_manager)
+        self._init_cache(cacheDuration)
+
+    def _fetch_uncached(self, accessor: ViCareDeviceAccessor) -> Any:
+        return ViCareServiceViaGateway.fetch_all_features(self, accessor)
+
+    def _extract_entities(self, data: dict, accessor: ViCareDeviceAccessor) -> list[dict[str, Any]]:
+        return filter_features_for_device(data["data"], accessor.device_id)
+
+    def fetch_all_features(self, accessor: ViCareDeviceAccessor) -> Any:
+        # cached too, so per-device coordinators share one bulk fetch
+        return self._get_or_update_cache(accessor)

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareDevice.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from PyViCare.PyViCareService import ViCareService
+from PyViCare.PyViCareService import ViCareDeviceAccessor, ViCareService, hasRoles
 from PyViCare.PyViCareUtils import PyViCareNotSupportedFeatureError, handleAPICommandErrors, handleNotSupported
 
 
@@ -11,14 +11,16 @@ class Device:
     Note that currently, a new token is generated for each run.
     """
 
-    def __init__(self, service: ViCareService) -> None:
+    def __init__(self, accessor: ViCareDeviceAccessor, service: ViCareService, roles: list[str] | None = None) -> None:
+        self.accessor = accessor
         self.service = service
+        self.roles = roles if roles is not None else []
 
     def getProperty(self, property_name: str) -> Any:
-        return self.service.getProperty(property_name)
+        return self.service.getProperty(self.accessor, property_name)
 
     def setProperty(self, property_name: str, action: str, data: Any) -> Any:
-        return self.service.setProperty(property_name, action, data)
+        return self.service.setProperty(self.accessor, property_name, action, data)
 
     @handleNotSupported
     def getSerial(self):
@@ -29,10 +31,10 @@ class Device:
         return list[Any](self.getProperty("device.messages.errors.raw")["properties"]["entries"]["value"])
 
     def isLegacyDevice(self) -> bool:
-        return self.service.hasRoles(["type:legacy"])
+        return hasRoles(["type:legacy"], self.roles)
 
     def isE3Device(self) -> bool:
-        return self.service.hasRoles(["type:E3"])
+        return hasRoles(["type:E3"], self.roles)
 
     def isDomesticHotWaterDevice(self):
         return self._isTypeDevice("heating.dhw")

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareDeviceConfig.py

@@ -16,6 +16,9 @@ from PyViCare.PyViCareRoomSensor import RoomSensor
 from PyViCare.PyViCareRepeater import Repeater
 from PyViCare.PyViCareElectricalEnergySystem import ElectricalEnergySystem
 from PyViCare.PyViCareGateway import Gateway
+from PyViCare.PyViCareService import (ViCareDeviceAccessor, ViCareService,
+                                      hasRoles, is_gateway_role)
+from PyViCare.PyViCareUtils import PyViCareNotPaidForError
 from PyViCare.PyViCareVentilationDevice import VentilationDevice
 
 logger = logging.getLogger(__name__)
@@ -24,74 +27,65 @@ logger.addHandler(logging.NullHandler())
 
 class PyViCareDeviceConfig:
     # pylint: disable=too-many-arguments,too-many-positional-arguments,too-many-instance-attributes
-    def __init__(self, service, device_id, device_model, status, device_type=None, roles=None):
+    def __init__(self, accessor: ViCareDeviceAccessor, service: ViCareService, device_model, status, device_type=None, roles=None):
+        self.accessor = accessor
         self.service = service
-        self.device_id = device_id
+        self.device_id = accessor.device_id
         self.device_model = device_model
         self.status = status
         self.device_type = device_type
         self.roles = roles if roles is not None else []
-        self._room_control = None
-        self._room_id = None
 
     def asGeneric(self):
-        return HeatingDevice(self.service)
+        return HeatingDevice(self.accessor, self.service, self.roles)
 
     def asGazBoiler(self):
-        return GazBoiler(self.service)
+        return GazBoiler(self.accessor, self.service, self.roles)
 
     def asFuelCell(self):
-        return FuelCell(self.service)
+        return FuelCell(self.accessor, self.service, self.roles)
 
     def asHeatPump(self):
-        return HeatPump(self.service)
+        return HeatPump(self.accessor, self.service, self.roles)
 
     def asOilBoiler(self):
-        return OilBoiler(self.service)
+        return OilBoiler(self.accessor, self.service, self.roles)
 
     def asPelletsBoiler(self):
-        return PelletsBoiler(self.service)
+        return PelletsBoiler(self.accessor, self.service, self.roles)
 
     def asHybridDevice(self):
-        return Hybrid(self.service)
+        return Hybrid(self.accessor, self.service, self.roles)
 
     def asRadiatorActuator(self):
-        return RadiatorActuator(self.service)
+        return RadiatorActuator(self.accessor, self.service, self.roles)
 
     def asFloorHeating(self):
-        return FloorHeating(self.service)
+        return FloorHeating(self.accessor, self.service, self.roles)
 
     def asFloorHeatingChannel(self):
-        return FloorHeatingChannel(self.service)
+        return FloorHeatingChannel(self.accessor, self.service, self.roles)
 
     def asRoomSensor(self):
-        sensor = RoomSensor(self.service)
-        if self._room_control is not None:
-            sensor.setRoomControl(self._room_control, self._room_id)
-        return sensor
+        return RoomSensor(self.accessor, self.service, self.roles)
 
     def asRoomControl(self):
-        return RoomControl(self.service)
-
-    def setRoomControlEnrichment(self, room_control, room_id):
-        """Store RoomControl enrichment data to apply when creating a RoomSensor."""
-        self._room_control = room_control
-        self._room_id = room_id
+        return RoomControl(self.accessor, self.service, self.roles)
 
     def asRepeater(self):
-        return Repeater(self.service)
+        return Repeater(self.accessor, self.service, self.roles)
 
     def asElectricalEnergySystem(self):
-        return ElectricalEnergySystem(self.service)
+        return ElectricalEnergySystem(self.accessor, self.service, self.roles)
 
     def asGateway(self):
-        return Gateway(self.service)
+        return Gateway(self.accessor, self.service, self.roles)
 
     def asVentilation(self):
-        return VentilationDevice(self.service)
+        return VentilationDevice(self.accessor, self.service, self.roles)
 
     def getConfig(self):
-        return self.service.accessor
+        return self.accessor
 
     def getId(self):
         return self.device_id
@@ -108,8 +102,11 @@ class PyViCareDeviceConfig:
     def getRoles(self):
         return self.roles
 
+    def hasRoles(self, requested_roles):
+        return hasRoles(requested_roles, self.roles)
+
     def isGateway(self):
-        return self.service._isGateway()  # pylint: disable=protected-access
+        return is_gateway_role(self.roles)
 
     # see: https://vitodata300.viessmann.com/vd300/ApplicationHelp/VD300/1031_de_DE/Ger%C3%A4teliste.html
     def asAutoDetectDevice(self):
@@ -138,7 +135,7 @@ class PyViCareDeviceConfig:
         ]
 
         for (creator_method, type_name, roles) in device_types:
-            if re.search(type_name, self.device_model) or self.service.hasRoles(roles):
+            if re.search(type_name, self.device_model) or self.hasRoles(roles):
                 logger.info("detected %s %s", self.device_model, creator_method.__name__)
                 device = creator_method()
                 if isinstance(device, (GazBoiler, HeatPump)) and not isinstance(device, Hybrid):
@@ -153,20 +150,27 @@ class PyViCareDeviceConfig:
     def _isHybridByFeatures(self):
         """Check API features to detect hybrid devices (both burners and compressors)."""
         try:
-            features = self.service.fetch_all_features()
+            features = self.service.fetch_all_features(self.accessor)
             feature_names = [f["feature"] for f in features.get("data", [])]
             has_burners = any(f.startswith("heating.burners") for f in feature_names)
             has_compressors = any(f.startswith("heating.compressors") for f in feature_names)
             return has_burners and has_compressors
+        except PyViCareNotPaidForError:
+            # Account lacks the paid feature package, so feature listing is
+            # unavailable. Treat as non-hybrid and let downstream feature
+            # access fall back to PyViCareNotSupportedFeatureError via the
+            # cached service. Without this, auto-detection crashes the
+            # integration setup before any device is created.
+            logger.debug("PACKAGE_NOT_PAID_FOR while detecting hybrid for %s, treating as non-hybrid", self.device_model)
+            return False
         except (KeyError, TypeError, AttributeError, OSError):
             logger.debug("Could not fetch features for hybrid detection of %s", self.device_model)
             return False
 
     def get_raw_json(self):
-        return self.service.fetch_all_features()
+        return self.service.fetch_all_features(self.accessor)
 
     def dump_secure(self, flat=False):
-        raw_data = self.get_raw_json()
         device_info = {
             "id": self.device_id,
             "modelId": self.device_model,
@@ -174,9 +178,20 @@ class PyViCareDeviceConfig:
             "status": self.status,
             "roles": self.roles
         }
+        try:
+            raw_data = self.get_raw_json()
+            data = raw_data['data']
+        except PyViCareNotPaidForError:
+            # Feature listing requires a paid package the account does not
+            # have. Emit a placeholder so diagnostics still produce a usable
+            # dump (device metadata plus an unavailable-reason marker)
+            # rather than crashing the diagnostics endpoint.
+            logger.debug("PACKAGE_NOT_PAID_FOR while dumping features for %s", self.device_model)
+            data = []
+            device_info["dataUnavailableReason"] = "PACKAGE_NOT_PAID_FOR"
         output = {
             "device": device_info,
-            "data": raw_data['data']
+            "data": data
         }
 
         if flat:

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareFuelCell.py

@@ -17,7 +17,7 @@ class FuelCell(HeatingDevice):
 
     @handleNotSupported
     def getAvailableBurners(self):
-        return get_available_burners(self.service)
+        return get_available_burners(self)
 
     @handleNotSupported
     def getReturnTemperature(self):

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareGazBoiler.py

@@ -17,7 +17,7 @@ class GazBoiler(HeatingDevice):
 
     @handleNotSupported
     def getAvailableBurners(self):
-        return get_available_burners(self.service)
+        return get_available_burners(self)
 
     @handleNotSupported
     def getGasConsumptionHeatingUnit(self):
@@ -91,10 +91,6 @@ class GazBoiler(HeatingDevice):
     def getGasConsumptionDomesticHotWaterThisYear(self):
         return self.getProperty("heating.gas.consumption.dhw")["properties"]["year"]["value"][0]
 
-    @handleNotSupported
-    def getBoilerTemperature(self):
-        return self.getProperty("heating.boiler.sensors.temperature.main")["properties"]["value"]["value"]
-
     @handleNotSupported
     def getBoilerTargetTemperature(self):
         return self.getProperty("heating.boiler.temperature")["properties"]["value"]["value"]

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareHeatingDevice.py

@@ -2,6 +2,7 @@ from contextlib import suppress
 from typing import Any, List, Optional
 
 from PyViCare.PyViCareDevice import Device
+from PyViCare.PyViCareService import hasRoles
 from PyViCare.PyViCareHeatCurveCalculation import (
     heat_curve_formular_variant1, heat_curve_formular_variant2)
 from PyViCare.PyViCareUtils import (VICARE_DAYS,
@@ -17,13 +18,13 @@ def all_set(_list: List[Any]) -> bool:
     return all(v is not None for v in _list)
 
 
-def get_available_burners(service):
+def get_available_burners(device):
     # workaround starting from 25.01.2022
     # see: https://github.com/somm15/PyViCare/issues/243
     available_burners = []
     for burner in ['0', '1', '2', '3', '4', '5']:
         with suppress(PyViCareNotSupportedFeatureError):
-            if service.getProperty(f"heating.burners.{burner}") is not None:
+            if device.getProperty(f"heating.burners.{burner}") is not None:
                 available_burners.append(burner)
 
     return available_burners
@@ -48,9 +49,9 @@ class HeatingDevice(Device):
         return HeatingCircuit(self, circuit)
 
     def get_heat_curve_formular(self):
-        if self.service.hasRoles(["type:heatpump", "type:E3"]):
+        if hasRoles(["type:heatpump", "type:E3"], self.roles):
             return heat_curve_formular_variant1
-        if self.service.hasRoles(["type:heatpump"]) and len(self.getAvailableCircuits()) == 1:
+        if hasRoles(["type:heatpump"], self.roles) and len(self.getAvailableCircuits()) == 1:
             return heat_curve_formular_variant2
         return heat_curve_formular_variant1
 
@@ -391,6 +392,10 @@ class HeatingDevice(Device):
     def getBoilerCommonSupplyTemperature(self):
         return self.getProperty("heating.boiler.sensors.temperature.commonSupply")["properties"]["value"]["value"]
 
+    @handleNotSupported
+    def getBoilerTemperature(self):
+        return self.getProperty("heating.boiler.sensors.temperature.main")["properties"]["value"]["value"]
+
 
 class HeatingDeviceWithComponent:
     """This is the base class for all heating components"""
@@ -699,6 +704,16 @@ class HeatingCircuit(HeatingDeviceWithComponent):
             "sun": properties["entries"]["value"]["sun"]
         }
 
+    @handleAPICommandErrors
+    def setHeatingSchedule(self, schedule: dict) -> None:
+        self.device.setProperty(f"heating.circuits.{self.circuit}.heating.schedule",
+                                "setSchedule", {'newSchedule': schedule})
+
+    @handleNotSupported
+    def getHeatingScheduleModes(self) -> list:  # type: ignore[type-arg]
+        return list(self.getProperty(f"heating.circuits.{self.circuit}.heating.schedule"
+            )["commands"]["setSchedule"]["params"]["newSchedule"]["constraints"]["modes"])
+
     # Calculates target supply temperature based on data from Viessmann
     # See: https://www.viessmann-community.com/t5/Gas/Mathematische-Formel-fuer-Vorlauftemperatur-aus-den-vier/m-p/68890#M27556
     def getTargetSupplyTemperature(self) -> Optional[float]:

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareOilBoiler.py

@@ -17,7 +17,7 @@ class OilBoiler(HeatingDevice):
 
     @handleNotSupported
     def getAvailableBurners(self):
-        return get_available_burners(self.service)
+        return get_available_burners(self)
 
     @handleNotSupported
     def getBoilerTemperature(self):

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCarePelletsBoiler.py

@@ -16,7 +16,7 @@ class PelletsBoiler(HeatingDevice):
 
     @handleNotSupported
     def getAvailableBurners(self):
-        return get_available_burners(self.service)
+        return get_available_burners(self)
 
     @handleNotSupported
     def getBoilerTemperature(self):

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareRoomControl.py

@@ -11,89 +11,88 @@ logger.addHandler(logging.NullHandler())
 class RoomControl(Device):
     """Viessmann RoomControl virtual device.
 
-    Aggregates room sensor data and heating programs.
-    Used to enrich physical Zigbee devices with room data.
+    Aggregates room sensor data and heating programs per room.
     """
 
     @handleNotSupported
     def getAvailableRooms(self) -> list[str]:
-        return cast(list[str], self.service.getProperty("rooms")["properties"]["enabled"]["value"])
+        return cast(list[str], self.getProperty("rooms")["properties"]["enabled"]["value"])
 
     def getRoomActorIds(self, room_id: str) -> list[str]:
         """Return list of actor device IDs for a room."""
         try:
-            actors = self.service.getProperty(f"rooms.{room_id}")["properties"]["actors"]["value"]
+            actors = self.getProperty(f"rooms.{room_id}")["properties"]["actors"]["value"]
             return [str(a["deviceId"]) for a in actors]
         except (PyViCareNotSupportedFeatureError, KeyError):
             return []
 
     def getRoomName(self, room_id: str) -> str | None:
         try:
-            return str(self.service.getProperty(f"rooms.{room_id}")["properties"]["name"]["value"])
+            return str(self.getProperty(f"rooms.{room_id}")["properties"]["name"]["value"])
         except (PyViCareNotSupportedFeatureError, KeyError):
             return None
 
     def getRoomType(self, room_id: str) -> str | None:
         try:
-            return str(self.service.getProperty(f"rooms.{room_id}")["properties"]["type"]["value"])
+            return str(self.getProperty(f"rooms.{room_id}")["properties"]["type"]["value"])
         except (PyViCareNotSupportedFeatureError, KeyError):
             return None
 
     # --- Sensors ---
 
     def getRoomTemperature(self, room_id: str) -> float:
-        return float(self.service.getProperty(f"rooms.{room_id}.sensors.temperature")["properties"]["value"]["value"])
+        return float(self.getProperty(f"rooms.{room_id}.sensors.temperature")["properties"]["value"]["value"])
 
     def getRoomHumidity(self, room_id: str) -> float:
-        return float(self.service.getProperty(f"rooms.{room_id}.sensors.humidity")["properties"]["value"]["value"])
+        return float(self.getProperty(f"rooms.{room_id}.sensors.humidity")["properties"]["value"]["value"])
 
     def getRoomCO2(self, room_id: str) -> int:
-        return int(self.service.getProperty(f"rooms.{room_id}.sensors.co2")["properties"]["value"]["value"])
+        return int(self.getProperty(f"rooms.{room_id}.sensors.co2")["properties"]["value"]["value"])
 
     def getRoomCondensationRisk(self, room_id: str) -> bool:
-        return bool(self.service.getProperty(f"rooms.{room_id}.condensationRisk")["properties"]["value"]["value"])
+        return bool(self.getProperty(f"rooms.{room_id}.condensationRisk")["properties"]["value"]["value"])
 
     # --- Operating state ---
 
     def getRoomOperatingStateLevel(self, room_id: str) -> str:
-        return str(self.service.getProperty(f"rooms.{room_id}.operating.state")["properties"]["level"]["value"])
+        return str(self.getProperty(f"rooms.{room_id}.operating.state")["properties"]["level"]["value"])
 
     def getRoomOperatingStateDemand(self, room_id: str) -> str:
-        return str(self.service.getProperty(f"rooms.{room_id}.operating.state")["properties"]["demand"]["value"])
+        return str(self.getProperty(f"rooms.{room_id}.operating.state")["properties"]["demand"]["value"])
 
     def getRoomOperatingStateReason(self, room_id: str) -> str:
-        return str(self.service.getProperty(f"rooms.{room_id}.operating.state")["properties"]["reason"]["value"])
+        return str(self.getProperty(f"rooms.{room_id}.operating.state")["properties"]["reason"]["value"])
 
     # --- Heating programs ---
 
     def getRoomNormalHeatingTemperature(self, room_id: str) -> float:
-        return float(self.service.getProperty(f"rooms.{room_id}.operating.programs.normalHeating")["properties"]["temperature"]["value"])
+        return float(self.getProperty(f"rooms.{room_id}.operating.programs.normalHeating")["properties"]["temperature"]["value"])
 
     @handleAPICommandErrors
     def setRoomNormalHeatingTemperature(self, room_id: str, temperature: float) -> None:
-        self.service.setProperty(f"rooms.{room_id}.operating.programs.normalHeating", "setTemperature",
+        self.setProperty(f"rooms.{room_id}.operating.programs.normalHeating", "setTemperature",
                                  {"targetTemperature": temperature})
 
     def getRoomReducedHeatingTemperature(self, room_id: str) -> float:
-        return float(self.service.getProperty(f"rooms.{room_id}.operating.programs.reducedHeating")["properties"]["temperature"]["value"])
+        return float(self.getProperty(f"rooms.{room_id}.operating.programs.reducedHeating")["properties"]["temperature"]["value"])
 
     @handleAPICommandErrors
     def setRoomReducedHeatingTemperature(self, room_id: str, temperature: float) -> None:
-        self.service.setProperty(f"rooms.{room_id}.operating.programs.reducedHeating", "setTemperature",
+        self.setProperty(f"rooms.{room_id}.operating.programs.reducedHeating", "setTemperature",
                                  {"targetTemperature": temperature})
 
     def getRoomComfortHeatingTemperature(self, room_id: str) -> float:
-        return float(self.service.getProperty(f"rooms.{room_id}.operating.programs.comfortHeating")["properties"]["temperature"]["value"])
+        return float(self.getProperty(f"rooms.{room_id}.operating.programs.comfortHeating")["properties"]["temperature"]["value"])
 
     @handleAPICommandErrors
     def setRoomComfortHeatingTemperature(self, room_id: str, temperature: float) -> None:
-        self.service.setProperty(f"rooms.{room_id}.operating.programs.comfortHeating", "setTemperature",
+        self.setProperty(f"rooms.{room_id}.operating.programs.comfortHeating", "setTemperature",
                                  {"targetTemperature": temperature})
 
     # --- Schedule ---
 
     def getRoomSchedule(self, room_id: str) -> dict[str, Any]:
-        props = self.service.getProperty(f"rooms.{room_id}.schedule")["properties"]
+        props = self.getProperty(f"rooms.{room_id}.schedule")["properties"]
         return {
             "active": props["active"]["value"],
             "mon": props["entries"]["value"]["mon"],
@@ -108,29 +107,14 @@ class RoomControl(Device):
     # --- Quick modes ---
 
     def getRoomManualTillNextScheduleActive(self, room_id: str) -> bool:
-        return bool(self.service.getProperty(
+        return bool(self.getProperty(
             f"rooms.{room_id}.quickmodes.manualTillNextSchedule")["properties"]["active"]["value"])
 
     @handleAPICommandErrors
     def activateRoomManualTillNextSchedule(self, room_id: str, temperature: float) -> None:
-        self.service.setProperty(f"rooms.{room_id}.quickmodes.manualTillNextSchedule", "activate",
+        self.setProperty(f"rooms.{room_id}.quickmodes.manualTillNextSchedule", "activate",
                                  {"temperature": temperature})
 
     @handleAPICommandErrors
     def deactivateRoomManualTillNextSchedule(self, room_id: str) -> None:
-        self.service.setProperty(f"rooms.{room_id}.quickmodes.manualTillNextSchedule", "deactivate", {})
-
-    # --- Mapping ---
-
-    def buildActorRoomMap(self) -> dict[str, str]:
-        """Build a mapping of actor device ID -> room ID."""
-        actor_map: dict[str, str] = {}
-        try:
-            rooms = self.getAvailableRooms()
-        except PyViCareNotSupportedFeatureError:
-            return actor_map
-
-        for room_id in rooms:
-            for actor_id in self.getRoomActorIds(room_id):
-                actor_map[actor_id] = room_id
-        return actor_map
+        self.setProperty(f"rooms.{room_id}.quickmodes.manualTillNextSchedule", "deactivate", {})

pyvicare-2.61.0/PyViCare/PyViCareRoomSensor.py

@@ -0,0 +1,17 @@
+from PyViCare.PyViCareDevice import ZigbeeBatteryDevice
+from PyViCare.PyViCareUtils import handleNotSupported
+
+
+class RoomSensor(ZigbeeBatteryDevice):
+
+    @handleNotSupported
+    def getSerial(self) -> str:
+        return str(self.getProperty("device.sensors.temperature")["deviceId"])
+
+    @handleNotSupported
+    def getTemperature(self) -> float:
+        return float(self.getProperty("device.sensors.temperature")["properties"]["value"]["value"])
+
+    @handleNotSupported
+    def getHumidity(self) -> float:
+        return float(self.getProperty("device.sensors.humidity")["properties"]["value"]["value"])

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareService.py

@@ -20,6 +20,17 @@ def readFeature(entities, property_name):
 def hasRoles(requested_roles: List[str], existing_roles: List[str]) -> bool:
     return len(requested_roles) > 0 and set(requested_roles).issubset(set(existing_roles))
 
+GATEWAY_ROLES = [
+    "type:gateway;VitoconnectOpto1",
+    "type:gateway;VitoconnectOpto2/OT2",
+    "type:gateway;TCU100",
+    "type:gateway;TCU200",
+    "type:gateway;TCU300",
+]
+
+def is_gateway_role(roles: List[str]) -> bool:
+    return any(hasRoles([role], roles) for role in GATEWAY_ROLES)
+
 def buildSetPropertyUrl(accessor, property_name, action):
     return f'/features/installations/{accessor.id}/gateways/{accessor.serial}/devices/{accessor.device_id}/features/{property_name}/commands/{action}'
 
@@ -30,40 +41,35 @@ class ViCareDeviceAccessor:
         self.device_id = device_id
 
 class ViCareService:
-    def __init__(self, oauth_manager: AbstractViCareOAuthManager, accessor: ViCareDeviceAccessor, roles: List[str]) -> None:
+    def __init__(self, oauth_manager: AbstractViCareOAuthManager, roles: List[str]) -> None:
         self.oauth_manager = oauth_manager
-        self.accessor = accessor
         self.roles = roles
 
-    def getProperty(self, property_name: str) -> Any:
-        url = self.buildGetPropertyUrl(property_name)
+    def getProperty(self, accessor: ViCareDeviceAccessor, property_name: str) -> Any:
+        url = self.buildGetPropertyUrl(accessor, property_name)
         return self.oauth_manager.get(url)
 
-    def buildGetPropertyUrl(self, property_name):
-        if self._isGateway():
-            return f'/features/installations/{self.accessor.id}/gateways/{self.accessor.serial}/features/{property_name}'
-        return f'/features/installations/{self.accessor.id}/gateways/{self.accessor.serial}/devices/{self.accessor.device_id}/features/{property_name}'
+    def buildGetPropertyUrl(self, accessor: ViCareDeviceAccessor, property_name):
+        if is_gateway_role(self.roles):
+            return f'/features/installations/{accessor.id}/gateways/{accessor.serial}/features/{property_name}'
+        return f'/features/installations/{accessor.id}/gateways/{accessor.serial}/devices/{accessor.device_id}/features/{property_name}'
 
     def hasRoles(self, requested_roles) -> bool:
         return hasRoles(requested_roles, self.roles)
 
-    def _isGateway(self) -> bool:
-        return self.hasRoles(["type:gateway;VitoconnectOpto1"]) or self.hasRoles(["type:gateway;VitoconnectOpto2/OT2"]) or self.hasRoles(["type:gateway;TCU100"]) or self.hasRoles(["type:gateway;TCU200"]) or self.hasRoles(["type:gateway;TCU300"])
-
-    def setProperty(self, property_name: str, action: str, data: Any) -> Any:
-        url = buildSetPropertyUrl(
-            self.accessor, property_name, action)
+    def setProperty(self, accessor: ViCareDeviceAccessor, property_name: str, action: str, data: Any) -> Any:
+        url = buildSetPropertyUrl(accessor, property_name, action)
 
         post_data = data if isinstance(data, str) else json.dumps(data)
         return self.oauth_manager.post(url, post_data)
 
-    def fetch_all_features(self) -> Any:
-        url = f'/features/installations/{self.accessor.id}/gateways/{self.accessor.serial}/devices/{self.accessor.device_id}/features/'
-        if self._isGateway():
-            url = f'/features/installations/{self.accessor.id}/gateways/{self.accessor.serial}/features/'
+    def fetch_all_features(self, accessor: ViCareDeviceAccessor) -> Any:
+        url = f'/features/installations/{accessor.id}/gateways/{accessor.serial}/devices/{accessor.device_id}/features/'
+        if is_gateway_role(self.roles):
+            url = f'/features/installations/{accessor.id}/gateways/{accessor.serial}/features/'
         return self.oauth_manager.get(url)
 
-    def reboot_gateway(self) -> Any:
-        url = f'/equipment/installations/{self.accessor.id}/gateways/{self.accessor.serial}/reboot'
+    def reboot_gateway(self, accessor: ViCareDeviceAccessor) -> Any:
+        url = f'/equipment/installations/{accessor.id}/gateways/{accessor.serial}/reboot'
         data = "{}"
         return self.oauth_manager.post(url, data)

pyvicare-2.61.0/PyViCare/PyViCareServiceViaGateway.py

@@ -0,0 +1,38 @@
+import logging
+from typing import Any
+
+from PyViCare.PyViCareAbstractOAuthManager import AbstractViCareOAuthManager
+from PyViCare.PyViCareService import (ViCareDeviceAccessor, ViCareService,
+                                      readFeature)
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+def filter_features_for_device(entities: list[dict[str, Any]], device_id: str) -> list[dict[str, Any]]:
+    device_segment = f"/devices/{device_id}/"
+    return [e for e in entities if device_segment in e.get("uri", "")]
+
+
+class ViCareServiceViaGateway(ViCareService):
+    """Service that reads all device features from the gateway-wide bulk endpoint.
+
+    One instance can serve multiple devices on the same gateway: the bulk
+    response contains features for all devices, and getProperty filters by
+    accessor.device_id at read time.
+    """
+
+    def __init__(self, oauth_manager: AbstractViCareOAuthManager) -> None:
+        ViCareService.__init__(self, oauth_manager, [])
+
+    def getProperty(self, accessor: ViCareDeviceAccessor, property_name: str) -> Any:
+        data = self.fetch_all_features(accessor)
+        entities = filter_features_for_device(data["data"], accessor.device_id)
+        return readFeature(entities, property_name)
+
+    def fetch_all_features(self, accessor: ViCareDeviceAccessor) -> Any:
+        url = (
+            f'/features/installations/{accessor.id}'
+            f'/gateways/{accessor.serial}/features?includeDevicesFeatures=true'
+        )
+        return self.oauth_manager.get(url)

{pyvicare-2.60.2 → pyvicare-2.61.0}/PyViCare/PyViCareVentilationDevice.py

@@ -119,6 +119,13 @@ class VentilationDevice(Device):
         self.setProperty(f"ventilation.quickmodes.{quickmode}", "deactivate", {})
 
     @handleNotSupported
+    @deprecated(
+        reason=(
+            "ventilation.operating.programs.* was deprecated by Viessmann on 2024-09-15. "
+            "Use getVentilationModes() instead."
+        ),
+        version="2.61.0",
+    )
     def getVentilationPrograms(self):
         available_programs = []
         for program in ['basic', 'intensive', 'reduced', 'standard', 'standby', 'holidayAtHome', 'permanent']:
@@ -133,6 +140,14 @@ class VentilationDevice(Device):
         return self.getVentilationPrograms()
 
     @handleNotSupported
+    @deprecated(
+        reason=(
+            "ventilation.operating.programs.* was deprecated by Viessmann on 2024-09-15. "
+            "Use getVentilationLevel() to read the current fan level "
+            "(from ventilation.operating.state) instead."
+        ),
+        version="2.61.0",
+    )
     def getActiveVentilationProgram(self):
         return self.getProperty("ventilation.operating.programs.active")["properties"]["value"]["value"]
 
@@ -141,6 +156,13 @@ class VentilationDevice(Device):
     def getActiveProgram(self):
         return self.getActiveVentilationProgram()
 
+    @deprecated(
+        reason=(
+            "ventilation.operating.programs.* was deprecated by Viessmann on 2024-09-15. "
+            "Use activateVentilationMode() and setVentilationLevel() instead."
+        ),
+        version="2.61.0",
+    )
     def activateVentilationProgram(self, program):
         """ Activate a program
             NOTE
@@ -172,6 +194,13 @@ class VentilationDevice(Device):
         """
         return self.activateVentilationProgram(program)
 
+    @deprecated(
+        reason=(
+            "ventilation.operating.programs.* was deprecated by Viessmann on 2024-09-15. "
+            "Use activateVentilationMode() with a different mode instead."
+        ),
+        version="2.61.0",
+    )
     def deactivateVentilationProgram(self, program):
         """ Deactivate a program
         Parameters

{pyvicare-2.60.2 → pyvicare-2.61.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "PyViCare"
-version = "2.60.2"
+version = "2.61.0"
 description = "Library to communicate with the Viessmann ViCare API."
 authors = [
   "Simon Gillet <mail+pyvicare@gillet.ninja>"
@@ -48,12 +48,12 @@ requests = ">=2.31.0"
 deprecated = "^1.2.15"
 
 [tool.poetry.group.dev.dependencies]
-codespell = "^2.3.0"
-mypy = "^1.11.2"
-pylint = "^4.0.0"
-pytest = "^9.0.0"
-pytest-cov = "^7.0.0"
-ruff = "^0.15.0"
+codespell = "2.4.2"
+mypy = "2.3.0"
+pylint = "4.0.6"
+pytest = "9.1.1"
+pytest-cov = "7.1.0"
+ruff = "0.15.21"
 types-deprecated = "^1.2.15.20241117"
 types-requests = ">=2.31"
 

pyvicare-2.60.2/PyViCare/PyViCareCachedService.py

@@ -1,72 +0,0 @@
-import logging
-import threading
-from typing import Any, List
-
-from PyViCare.PyViCareAbstractOAuthManager import AbstractViCareOAuthManager
-from PyViCare.PyViCareService import (ViCareDeviceAccessor, ViCareService,
-                                      readFeature)
-from PyViCare.PyViCareUtils import (PyViCareDeviceCommunicationError,
-                                    PyViCareInvalidDataError,
-                                    PyViCareInternalServerError,
-                                    PyViCareNotPaidForError,
-                                    PyViCareNotSupportedFeatureError,
-                                    ViCareTimer)
-
-logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
-
-
-class ViCareCachedService(ViCareService):
-
-    def __init__(self, oauth_manager: AbstractViCareOAuthManager, accessor: ViCareDeviceAccessor, roles: List[str], cacheDuration: int) -> None:
-        ViCareService.__init__(self, oauth_manager, accessor, roles)
-        self.__cacheDuration = cacheDuration
-        self.__cache = None
-        self.__cacheTime = None
-        self.__lock = threading.Lock()
-
-    def getProperty(self, property_name: str) -> Any:
-        data = self.__get_or_update_cache()
-        entities = data["data"]
-        return readFeature(entities, property_name)
-
-    def setProperty(self, property_name, action, data):
-        response = super().setProperty(property_name, action, data)
-        self.clear_cache()
-        return response
-
-    def __get_or_update_cache(self):
-        with self.__lock:
-            if self.is_cache_invalid():
-                # we always set the cache time before we fetch the data
-                # to avoid consuming all the api calls if the api is down
-                # see https://github.com/home-assistant/core/issues/67052
-                # we simply return the old cache in this case
-                self.__cacheTime = ViCareTimer().now()
-
-                try:
-                    data = self.fetch_all_features()
-                except PyViCareNotPaidForError as e:
-                    logger.error("Viessmann API denied access (PACKAGE_NOT_PAID_FOR). Features unavailable: %s", e)
-                    if self.__cache is not None:
-                        return self.__cache
-                    raise PyViCareNotSupportedFeatureError("PACKAGE_NOT_PAID_FOR")
-                except (PyViCareDeviceCommunicationError, PyViCareInternalServerError) as e:
-                    if self.__cache is not None:
-                        logger.warning("API error, returning stale cache: %s", e)
-                        return self.__cache
-                    raise
-
-                if "data" not in data:
-                    logger.error("Missing 'data' property when fetching data.")
-                    raise PyViCareInvalidDataError(data)
-                self.__cache = data
-            return self.__cache
-
-    def is_cache_invalid(self) -> bool:
-        return self.__cache is None or self.__cacheTime is None or (ViCareTimer().now() - self.__cacheTime).seconds > self.__cacheDuration
-
-    def clear_cache(self):
-        with self.__lock:
-            self.__cache = None
-            self.__cacheTime = None

pyvicare-2.60.2/PyViCare/PyViCareRoomSensor.py

@@ -1,132 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, TYPE_CHECKING
-
-from PyViCare.PyViCareDevice import ZigbeeBatteryDevice
-from PyViCare.PyViCareUtils import handleNotSupported, handleAPICommandErrors
-
-if TYPE_CHECKING:
-    from PyViCare.PyViCareRoomControl import RoomControl
-
-
-class RoomSensor(ZigbeeBatteryDevice):
-
-    _room_control: RoomControl | None = None
-    _room_id: str | None = None
-
-    def setRoomControl(self, room_control: RoomControl, room_id: str) -> None:
-        """Enrich this sensor with data from a RoomControl device."""
-        self._room_control = room_control
-        self._room_id = room_id
-
-    def _getRoomContext(self) -> tuple[RoomControl, str]:
-        """Return (room_control, room_id), raising if not enriched."""
-        if self._room_control is None or self._room_id is None:
-            raise KeyError("roomControl")
-        return self._room_control, self._room_id
-
-    @handleNotSupported
-    def getSerial(self) -> str:
-        return str(self.getProperty("device.sensors.temperature")["deviceId"])
-
-    # --- Sensors (enriched from RoomControl) ---
-
-    @handleNotSupported
-    def getTemperature(self) -> float:
-        if self._room_control is not None and self._room_id is not None:
-            return self._room_control.getRoomTemperature(self._room_id)
-        return float(self.getProperty("device.sensors.temperature")["properties"]["value"]["value"])
-
-    @handleNotSupported
-    def getHumidity(self) -> float:
-        if self._room_control is not None and self._room_id is not None:
-            return self._room_control.getRoomHumidity(self._room_id)
-        return float(self.getProperty("device.sensors.humidity")["properties"]["value"]["value"])
-
-    @handleNotSupported
-    def getCO2(self) -> int:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomCO2(rid)
-
-    @handleNotSupported
-    def getRoomName(self) -> str | None:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomName(rid)
-
-    @handleNotSupported
-    def getRoomType(self) -> str | None:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomType(rid)
-
-    @handleNotSupported
-    def getCondensationRisk(self) -> bool:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomCondensationRisk(rid)
-
-    # --- Operating state ---
-
-    @handleNotSupported
-    def getOperatingStateLevel(self) -> str:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomOperatingStateLevel(rid)
-
-    @handleNotSupported
-    def getOperatingStateDemand(self) -> str:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomOperatingStateDemand(rid)
-
-    # --- Heating programs ---
-
-    @handleNotSupported
-    def getNormalHeatingTemperature(self) -> float:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomNormalHeatingTemperature(rid)
-
-    @handleAPICommandErrors
-    def setNormalHeatingTemperature(self, temperature: float) -> None:
-        rc, rid = self._getRoomContext()
-        rc.setRoomNormalHeatingTemperature(rid, temperature)
-
-    @handleNotSupported
-    def getReducedHeatingTemperature(self) -> float:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomReducedHeatingTemperature(rid)
-
-    @handleAPICommandErrors
-    def setReducedHeatingTemperature(self, temperature: float) -> None:
-        rc, rid = self._getRoomContext()
-        rc.setRoomReducedHeatingTemperature(rid, temperature)
-
-    @handleNotSupported
-    def getComfortHeatingTemperature(self) -> float:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomComfortHeatingTemperature(rid)
-
-    @handleAPICommandErrors
-    def setComfortHeatingTemperature(self, temperature: float) -> None:
-        rc, rid = self._getRoomContext()
-        rc.setRoomComfortHeatingTemperature(rid, temperature)
-
-    # --- Quick modes ---
-
-    @handleNotSupported
-    def getManualTillNextScheduleActive(self) -> bool:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomManualTillNextScheduleActive(rid)
-
-    @handleAPICommandErrors
-    def activateManualTillNextSchedule(self, temperature: float) -> None:
-        rc, rid = self._getRoomContext()
-        rc.activateRoomManualTillNextSchedule(rid, temperature)
-
-    @handleAPICommandErrors
-    def deactivateManualTillNextSchedule(self) -> None:
-        rc, rid = self._getRoomContext()
-        rc.deactivateRoomManualTillNextSchedule(rid)
-
-    # --- Schedule ---
-
-    @handleNotSupported
-    def getSchedule(self) -> dict[str, Any]:
-        rc, rid = self._getRoomContext()
-        return rc.getRoomSchedule(rid)