PyViCare 2.60.2__tar.gz → 2.62.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyViCare
-Version: 2.60.2
+Version: 2.62.0
 Summary: Library to communicate with the Viessmann ViCare API.
 License: Apache-2.0
 License-File: LICENSE
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: authlib (>1.2.0)
-Requires-Dist: deprecated (>=1.2.15,<2.0.0)
+Requires-Dist: deprecated (>=1.3.0,<2.0.0)
 Requires-Dist: requests (>=2.31.0)
 Project-URL: Bug Tracker, https://github.com/openviess/PyViCare/issues
 Project-URL: Changelog, https://github.com/openviess/PyViCare/releases

{pyvicare-2.60.2 → pyvicare-2.62.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.62.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.62.0/PyViCare/PyViCareCachedServiceBase.py

@@ -0,0 +1,87 @@
+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 fetch_all_features(self, accessor: ViCareDeviceAccessor) -> Any:
+        # cached, so a caller refreshing with fetch_all_features() warms the
+        # cache the following getProperty calls read from
+        return self._get_or_update_cache(accessor)
+
+    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.62.0/PyViCare/PyViCareCachedServiceViaGateway.py

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

{pyvicare-2.60.2 → pyvicare-2.62.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.62.0}/PyViCare/PyViCareDeviceConfig.py

@@ -16,7 +16,11 @@ 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
+from PyViCare.PyViCareWaterTreatment import WaterTreatment
 
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
@@ -24,74 +28,68 @@ 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 asWaterTreatment(self):
+        return WaterTreatment(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 +106,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):
@@ -130,6 +131,7 @@ class PyViCareDeviceConfig:
             (self.asRoomControl, r"E3_RoomControl|Smart_RoomControl", ["type:virtual;smartRoomControl"]),
             (self.asRoomSensor, r"E3_RoomSensor", ["type:climateSensor"]),
             (self.asRepeater, r"E3_Repeater", ["type:repeater"]),
+            (self.asWaterTreatment, r"VitosetAqua", ["type:waterTreatment"]),
             (self.asGateway, r"E3_TCU41_x04", ["type:gateway;TCU100"]),
             (self.asGateway, r"E3_TCU19_x05", ["type:gateway;TCU200"]),
             (self.asGateway, r"E3_TCU10_x07", ["type:gateway;TCU300"]),
@@ -138,7 +140,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 +155,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 +183,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.62.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.62.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.62.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.62.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.62.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):