plugwise 0.37.1a2__py3-none-any.whl → 0.37.2__py3-none-any.whl

plugwise/common.py

@@ -4,11 +4,23 @@ Plugwise Smile protocol helpers.
 """
 from __future__ import annotations
 
-from plugwise.constants import ModelData
+from typing import cast
+
+from plugwise.constants import (
+    ANNA,
+    SPECIAL_PLUG_TYPES,
+    SWITCH_GROUP_TYPES,
+    ApplianceType,
+    DeviceData,
+    ModelData,
+    SensorType,
+)
 from plugwise.util import (
+    check_alternative_location,
     check_heater_central,
     check_model,
     get_vendor_name,
+    power_data_local_format,
     return_valid,
 )
 
@@ -22,31 +34,20 @@ class SmileCommon:
     def __init__(self) -> None:
         """Init."""
         self._appliances: etree
+        self._count: int
         self._domain_objects: etree
         self._cooling_present: bool
         self._heater_id: str
         self._on_off_device: bool
         self._opentherm_device: bool
+        self.gw_devices: dict[str, DeviceData]
         self.smile_name: str
+        self.smile_type: str
 
     def smile(self, name: str) -> bool:
         """Helper-function checking the smile-name."""
         return self.smile_name == name
 
-    def _appl_thermostat_info(self, appl: Munch, xml_1: etree, xml_2: etree = None) -> Munch:
-        """Helper-function for _appliance_info_finder()."""
-        locator = "./logs/point_log[type='thermostat']/thermostat"
-        mod_type = "thermostat"
-        xml_2 = return_valid(xml_2, self._domain_objects)
-        module_data = self._get_module_data(xml_1, locator, mod_type, xml_2)
-        appl.vendor_name = module_data["vendor_name"]
-        appl.model = check_model(module_data["vendor_model"], appl.vendor_name)
-        appl.hardware = module_data["hardware_version"]
-        appl.firmware = module_data["firmware_version"]
-        appl.zigbee_mac = module_data["zigbee_mac_address"]
-
-        return appl
-
     def _appl_heater_central_info(
         self,
         appl: Munch,
@@ -94,6 +95,184 @@ class SmileCommon:
 
         return appl
 
+    def _appl_thermostat_info(self, appl: Munch, xml_1: etree, xml_2: etree = None) -> Munch:
+        """Helper-function for _appliance_info_finder()."""
+        locator = "./logs/point_log[type='thermostat']/thermostat"
+        mod_type = "thermostat"
+        xml_2 = return_valid(xml_2, self._domain_objects)
+        module_data = self._get_module_data(xml_1, locator, mod_type, xml_2)
+        appl.vendor_name = module_data["vendor_name"]
+        appl.model = check_model(module_data["vendor_model"], appl.vendor_name)
+        appl.hardware = module_data["hardware_version"]
+        appl.firmware = module_data["firmware_version"]
+        appl.zigbee_mac = module_data["zigbee_mac_address"]
+
+        return appl
+
+    def _collect_power_values(self, data: DeviceData, loc: Munch, tariff: str, legacy: bool = False) -> None:
+        """Something."""
+        for loc.peak_select in ("nl_peak", "nl_offpeak"):
+            loc.locator = (
+                f'./{loc.log_type}[type="{loc.measurement}"]/period/'
+                f'measurement[@{tariff}="{loc.peak_select}"]'
+            )
+            if legacy:
+                loc.locator = (
+                    f"./{loc.meas_list[0]}_{loc.log_type}/measurement"
+                    f'[@directionality="{loc.meas_list[1]}"][@{tariff}="{loc.peak_select}"]'
+                )
+
+            loc = self._power_data_peak_value(loc, legacy)
+            if not loc.found:
+                continue
+
+            data = self._power_data_energy_diff(
+                loc.measurement, loc.net_string, loc.f_val, data
+            )
+            key = cast(SensorType, loc.key_string)
+            data["sensors"][key] = loc.f_val
+
+    def _power_data_peak_value(self, loc: Munch, legacy: bool) -> Munch:
+        """Helper-function for _power_data_from_location() and _power_data_from_modules()."""
+        loc.found = True
+        if loc.logs.find(loc.locator) is None:
+            loc = check_alternative_location(loc, legacy)
+            if not loc.found:
+                return loc
+
+        if (peak := loc.peak_select.split("_")[1]) == "offpeak":
+            peak = "off_peak"
+        log_found = loc.log_type.split("_")[0]
+        loc.key_string = f"{loc.measurement}_{peak}_{log_found}"
+        if "gas" in loc.measurement or loc.log_type == "point_meter":
+            loc.key_string = f"{loc.measurement}_{log_found}"
+        # Only for P1 Actual -------------------#
+        if "phase" in loc.measurement:
+            loc.key_string = f"{loc.measurement}"
+        # --------------------------------------#
+        loc.net_string = f"net_electricity_{log_found}"
+        val = loc.logs.find(loc.locator).text
+        loc.f_val = power_data_local_format(loc.attrs, loc.key_string, val)
+
+        return loc
+
+    def _power_data_energy_diff(
+        self,
+        measurement: str,
+        net_string: SensorType,
+        f_val: float | int,
+        direct_data: DeviceData,
+    ) -> DeviceData:
+        """Calculate differential energy."""
+        if (
+            "electricity" in measurement
+            and "phase" not in measurement
+            and "interval" not in net_string
+        ):
+            diff = 1
+            if "produced" in measurement:
+                diff = -1
+            if net_string not in direct_data["sensors"]:
+                tmp_val: float | int = 0
+            else:
+                tmp_val = direct_data["sensors"][net_string]
+
+            if isinstance(f_val, int):
+                tmp_val += f_val * diff
+            else:
+                tmp_val += float(f_val * diff)
+                tmp_val = float(f"{round(tmp_val, 3):.3f}")
+
+            direct_data["sensors"][net_string] = tmp_val
+
+        return direct_data
+
+    def _create_gw_devices(self, appl: Munch) -> None:
+        """Helper-function for creating/updating gw_devices."""
+        self.gw_devices[appl.dev_id] = {"dev_class": appl.pwclass}
+        self._count += 1
+        for key, value in {
+            "firmware": appl.firmware,
+            "hardware": appl.hardware,
+            "location": appl.location,
+            "mac_address": appl.mac,
+            "model": appl.model,
+            "name": appl.name,
+            "zigbee_mac_address": appl.zigbee_mac,
+            "vendor": appl.vendor_name,
+        }.items():
+            if value is not None or key == "location":
+                appl_key = cast(ApplianceType, key)
+                self.gw_devices[appl.dev_id][appl_key] = value
+                self._count += 1
+
+    def _device_data_switching_group(
+        self, device: DeviceData, data: DeviceData
+    ) -> None:
+        """Helper-function for _get_device_data().
+
+        Determine switching group device data.
+        """
+        if device["dev_class"] in SWITCH_GROUP_TYPES:
+            counter = 0
+            for member in device["members"]:
+                if self.gw_devices[member]["switches"].get("relay"):
+                    counter += 1
+            data["switches"]["relay"] = counter != 0
+            self._count += 1
+
+    def _get_group_switches(self) -> dict[str, DeviceData]:
+        """Helper-function for smile.py: get_all_devices().
+
+        Collect switching- or pump-group info.
+        """
+        switch_groups: dict[str, DeviceData] = {}
+        # P1 and Anna don't have switchgroups
+        if self.smile_type == "power" or self.smile(ANNA):
+            return switch_groups
+
+        for group in self._domain_objects.findall("./group"):
+            members: list[str] = []
+            group_id = group.attrib["id"]
+            group_name = group.find("name").text
+            group_type = group.find("type").text
+            group_appliances = group.findall("appliances/appliance")
+            for item in group_appliances:
+                # Check if members are not orphaned - stretch
+                if item.attrib["id"] in self.gw_devices:
+                    members.append(item.attrib["id"])
+
+            if group_type in SWITCH_GROUP_TYPES and members:
+                switch_groups.update(
+                    {
+                        group_id: {
+                            "dev_class": group_type,
+                            "model": "Switchgroup",
+                            "name": group_name,
+                            "members": members,
+                        },
+                    },
+                )
+                self._count += 4
+
+        return switch_groups
+
+    def _get_lock_state(self, xml: etree, data: DeviceData, stretch_v2: bool = False) -> None:
+        """Helper-function for _get_measurement_data().
+
+        Adam & Stretches: obtain the relay-switch lock state.
+        """
+        actuator = "actuator_functionalities"
+        func_type = "relay_functionality"
+        if stretch_v2:
+            actuator = "actuators"
+            func_type = "relay"
+        if xml.find("type").text not in SPECIAL_PLUG_TYPES:
+            locator = f"./{actuator}/{func_type}/lock"
+            if (found := xml.find(locator)) is not None:
+                data["switches"]["lock"] = found.text == "true"
+                self._count += 1
+
     def _get_module_data(
         self,
         xml_1: etree,
@@ -148,4 +327,3 @@ class SmileCommon:
         elif (zb_node := module.find("./protocols/zig_bee_node")) is not None:
                 model_data["zigbee_mac_address"] = zb_node.find("mac_address").text
                 model_data["reachable"] = zb_node.find("reachable").text == "true"
-

plugwise/constants.py

@@ -121,21 +121,20 @@ P1_LEGACY_MEASUREMENTS: Final[dict[str, UOM]] = {
 # radiator_valve: 'uncorrected_temperature', 'temperature_offset'
 
 DEVICE_MEASUREMENTS: Final[dict[str, DATA | UOM]] = {
-    # HA Core thermostat current_temperature
-    "temperature": UOM(TEMP_CELSIUS),
-    # HA Core thermostat setpoint
-    "thermostat": DATA("setpoint", TEMP_CELSIUS),
-    # Specific for an Anna
-    "illuminance": UOM(UNIT_LUMEN),
+    "humidity": UOM(PERCENTAGE),  # Specific for a Jip
+    "illuminance": UOM(UNIT_LUMEN),  # Specific for an Anna
+    "temperature": UOM(TEMP_CELSIUS),  # HA Core thermostat current_temperature
+    "thermostat": DATA("setpoint", TEMP_CELSIUS),  # HA Core thermostat setpoint
+    ########################################################
     # Specific for an Anna with heatpump extension installed
     "cooling_activation_outdoor_temperature": UOM(TEMP_CELSIUS),
     "cooling_deactivation_threshold": UOM(TEMP_CELSIUS),
-    # Specific for a Lisa a Tom/Floor
+    ##################################
+    # Specific for a Lisa or Tom/Floor
     "battery": UOM(PERCENTAGE),
     "temperature_difference": UOM(DEGREE),
     "valve_position": UOM(PERCENTAGE),
-    # Specific for a Jip
-    "humidity": UOM(PERCENTAGE),
+    #####################
     # Specific for a Plug
     "electricity_consumed": UOM(POWER_WATT),
     "electricity_produced": UOM(POWER_WATT),
@@ -144,39 +143,43 @@ DEVICE_MEASUREMENTS: Final[dict[str, DATA | UOM]] = {
 
 # Heater Central related measurements
 HEATER_CENTRAL_MEASUREMENTS: Final[dict[str, DATA | UOM]] = {
+    "boiler_state": DATA(
+        "flame_state", NONE
+    ),  # Legacy Anna: similar to flame-state on Anna/Adam
     "boiler_temperature": DATA("water_temperature", TEMP_CELSIUS),
+    "central_heating_state": DATA(
+        "c_heating_state", NONE
+    ),  # For Elga (heatpump) use this instead of intended_central_heating_state
+    "central_heater_water_pressure": DATA("water_pressure", PRESSURE_BAR),
+    "compressor_state": UOM(NONE),  # present with heatpump
+    "cooling_enabled": UOM(
+        NONE
+    ),  # Available with the Loria and Elga (newer Anna firmware) heatpumps
+    "cooling_state": UOM(NONE),
     "domestic_hot_water_mode": DATA("select_dhw_mode", NONE),
     "domestic_hot_water_setpoint": UOM(TEMP_CELSIUS),
     "domestic_hot_water_state": DATA("dhw_state", NONE),
     "domestic_hot_water_temperature": DATA("dhw_temperature", TEMP_CELSIUS),
     "elga_status_code": UOM(NONE),
+    "intended_boiler_state": DATA(
+        "heating_state", NONE
+    ),  # Legacy Anna: shows when heating is active, we don't show dhw_state, cannot be determined reliably
+    "flame_state": UOM(
+        NONE
+    ),  # Also present when there is a single gas-heater
     "intended_boiler_temperature": UOM(
         TEMP_CELSIUS
     ),  # Non-zero when heating, zero when dhw-heating
-    "central_heating_state": DATA(
-        "c_heating_state", NONE
-    ),  # For Elga (heatpump) use this instead of intended_central_heating_state
     "intended_central_heating_state": DATA(
         "heating_state", NONE
     ),  # This key shows in general the heating-behavior better than c-h_state. except when connected to a heatpump
     "modulation_level": UOM(PERCENTAGE),
     "return_water_temperature": DATA("return_temperature", TEMP_CELSIUS),
-    # Used with the Elga heatpump - marcelveldt
-    "compressor_state": UOM(NONE),
-    "cooling_state": UOM(NONE),
-    "thermostat_supports_cooling": UOM(NONE),
-    # Available with the Loria and Elga (newer Anna firmware) heatpumps
-    "cooling_enabled": UOM(NONE),
-    # Next 2 keys are used to show the state of the gas-heater used next to the Elga heatpump - marcelveldt
-    "slave_boiler_state": UOM(NONE),
-    "flame_state": UOM(NONE),  # Also present when there is a single gas-heater
-    "central_heater_water_pressure": DATA("water_pressure", PRESSURE_BAR),
-    # Legacy Anna: similar to flame-state on Anna/Adam
-    "boiler_state": DATA("flame_state", NONE),
-    # Legacy Anna: shows when heating is active, we don't show dhw_state, cannot be determined reliably
-    "intended_boiler_state": DATA("heating_state", NONE),
-    # Outdoor temperature from APPLIANCES - present for a heatpump
-    "outdoor_temperature": DATA("outdoor_air_temperature", TEMP_CELSIUS),
+    "outdoor_temperature": DATA(
+        "outdoor_air_temperature", TEMP_CELSIUS
+    ),  # Outdoor temperature from APPLIANCES - present for a heatpump
+    "slave_boiler_state": DATA("secondary_boiler_state", NONE),
+    "thermostat_supports_cooling": UOM(NONE),  # present with heatpump
 }
 
 OBSOLETE_MEASUREMENTS: Final[tuple[str, ...]] = (
@@ -253,22 +256,22 @@ ApplianceType = Literal[
 ]
 
 BinarySensorType = Literal[
-    "cooling_enabled",
     "compressor_state",
+    "cooling_enabled",
     "cooling_state",
     "dhw_state",
     "flame_state",
     "heating_state",
     "plugwise_notification",
-    "slave_boiler_state",
+    "secondary_boiler_state",
 ]
 BINARY_SENSORS: Final[tuple[str, ...]] = get_args(BinarySensorType)
 
 LIMITS: Final[tuple[str, ...]] = (
+    "lower_bound",
     "offset",
-    "setpoint",
     "resolution",
-    "lower_bound",
+    "setpoint",
     "upper_bound",
 )
 
@@ -329,8 +332,8 @@ SENSORS: Final[tuple[str, ...]] = get_args(SensorType)
 
 SPECIAL_PLUG_TYPES: Final[tuple[str, ...]] = (
     "central_heating_pump",
-    "valve_actuator",
     "heater_electric",
+    "valve_actuator",
 )
 
 SpecialType = Literal[
@@ -350,14 +353,14 @@ SwitchType = Literal[
 ]
 SWITCHES: Final[tuple[str, ...]] = get_args(SwitchType)
 
-SWITCH_GROUP_TYPES: Final[tuple[str, ...]] = ("switching", "report")
+SWITCH_GROUP_TYPES: Final[tuple[str, ...]] = ("report", "switching")
 
 THERMOSTAT_CLASSES: Final[tuple[str, ...]] = (
     "thermostat",
+    "thermostatic_radiator_valve",
     "thermo_sensor",
     "zone_thermometer",
     "zone_thermostat",
-    "thermostatic_radiator_valve",
 )
 
 ToggleNameType = Literal[
@@ -392,25 +395,25 @@ class ModelData(TypedDict):
     """The ModelData class."""
 
     contents: bool
-    vendor_name: str | None
-    vendor_model: str | None
-    hardware_version: str | None
     firmware_version: str | None
-    zigbee_mac_address: str | None
+    hardware_version: str | None
     reachable: bool | None
+    vendor_model: str | None
+    vendor_name: str | None
+    zigbee_mac_address: str | None
 
 
 class SmileBinarySensors(TypedDict, total=False):
     """Smile Binary Sensors class."""
 
-    cooling_enabled: bool
     compressor_state: bool
+    cooling_enabled: bool
     cooling_state: bool
     dhw_state: bool
     flame_state: bool
     heating_state: bool
     plugwise_notification: bool
-    slave_boiler_state: bool
+    secondary_boiler_state: bool
 
 
 class SmileSensors(TypedDict, total=False):
@@ -482,9 +485,9 @@ class ThermoLoc(TypedDict, total=False):
     """Thermo Location class."""
 
     name: str
-    master: str | None
-    master_prio: int
-    slaves: set[str]
+    primary: str | None
+    primary_prio: int
+    secondary: set[str]
 
 
 class ActuatorData(TypedDict, total=False):

plugwise/data.py

@@ -11,7 +11,6 @@ from plugwise.constants import (
     MIN_SETPOINT,
     NONE,
     OFF,
-    SWITCH_GROUP_TYPES,
     ZONE_THERMOSTATS,
     ActuatorData,
     DeviceData,
@@ -28,6 +27,25 @@ class SmileData(SmileHelper):
         SmileHelper.__init__(self)
 
 
+    def _all_device_data(self) -> None:
+        """Helper-function for get_all_devices().
+
+        Collect data for each device and add to self.gw_data and self.gw_devices.
+        """
+        self._update_gw_devices()
+        self.gw_data.update(
+            {
+                "gateway_id": self.gateway_id,
+                "item_count": self._count,
+                "notifications": self._notifications,
+                "smile_name": self.smile_name,
+            }
+        )
+        if self._is_thermostat:
+            self.gw_data.update(
+                {"heater_id": self._heater_id, "cooling_present": self._cooling_present}
+            )
+
     def _update_gw_devices(self) -> None:
         """Helper-function for _all_device_data() and async_update().
 
@@ -84,39 +102,52 @@ class SmileData(SmileHelper):
             sensors["setpoint_high"] = temp_dict["setpoint_high"]
             self._count += 2
 
-    def _all_device_data(self) -> None:
-        """Helper-function for get_all_devices().
+    def _get_device_data(self, dev_id: str) -> DeviceData:
+        """Helper-function for _all_device_data() and async_update().
 
-        Collect data for each device and add to self.gw_data and self.gw_devices.
+        Provide device-data, based on Location ID (= dev_id), from APPLIANCES.
         """
-        self._update_gw_devices()
-        self.gw_data.update(
-            {
-                "gateway_id": self.gateway_id,
-                "item_count": self._count,
-                "notifications": self._notifications,
-                "smile_name": self.smile_name,
-            }
+        device = self.gw_devices[dev_id]
+        data = self._get_measurement_data(dev_id)
+
+        # Check availability of wired-connected devices
+        # Smartmeter
+        self._check_availability(
+            device, "smartmeter", data, "P1 does not seem to be connected"
         )
-        if self._is_thermostat:
-            self.gw_data.update(
-                {"heater_id": self._heater_id, "cooling_present": self._cooling_present}
+        # OpenTherm device
+        if device["name"] != "OnOff":
+            self._check_availability(
+                device, "heater_central", data, "no OpenTherm communication"
             )
 
-    def _device_data_switching_group(
-        self, device: DeviceData, data: DeviceData
+        # Switching groups data
+        self._device_data_switching_group(device, data)
+        # Adam data
+        self._device_data_adam(device, data)
+        # Skip obtaining data for (Adam) secondary thermostats
+        if device["dev_class"] not in ZONE_THERMOSTATS:
+            return data
+
+        # Thermostat data (presets, temperatures etc)
+        self._device_data_climate(device, data)
+
+        return data
+
+    def _check_availability(
+        self, device: DeviceData, dev_class: str, data: DeviceData, message: str
     ) -> None:
         """Helper-function for _get_device_data().
 
-        Determine switching group device data.
+        Provide availability status for the wired-commected devices.
         """
-        if device["dev_class"] in SWITCH_GROUP_TYPES:
-            counter = 0
-            for member in device["members"]:
-                if self.gw_devices[member]["switches"].get("relay"):
-                    counter += 1
-            data["switches"]["relay"] = counter != 0
+        if device["dev_class"] == dev_class:
+            data["available"] = True
             self._count += 1
+            for item in self._notifications.values():
+                for msg in item.values():
+                    if message in msg:
+                        data["available"] = False
 
     def _device_data_adam(self, device: DeviceData, data: DeviceData) -> None:
         """Helper-function for _get_device_data().
@@ -133,7 +164,7 @@ class SmileData(SmileHelper):
             ):
                 data["binary_sensors"]["heating_state"] = self._heating_valves() != 0
 
-            # Show the allowed regulation modes and gateway_modes
+            # Show the allowed regulation_modes and gateway_modes
             if device["dev_class"] == "gateway":
                 if self._reg_allowed_modes:
                     data["regulation_modes"] = self._reg_allowed_modes
@@ -142,7 +173,7 @@ class SmileData(SmileHelper):
                     data["gateway_modes"] = self._gw_allowed_modes
                     self._count += 1
 
-            # Control_state, only for Adam master thermostats
+            # Control_state, only available for Adam primary thermostats
             if device["dev_class"] in ZONE_THERMOSTATS:
                 loc_id = device["location"]
                 if ctrl_state := self._control_state(loc_id):
@@ -213,50 +244,3 @@ class SmileData(SmileHelper):
                 all_off = False
         if all_off:
             data["select_schedule"] = OFF
-
-    def _check_availability(
-        self, device: DeviceData, dev_class: str, data: DeviceData, message: str
-    ) -> None:
-        """Helper-function for _get_device_data().
-
-        Provide availability status for the wired-commected devices.
-        """
-        if device["dev_class"] == dev_class:
-            data["available"] = True
-            self._count += 1
-            for item in self._notifications.values():
-                for msg in item.values():
-                    if message in msg:
-                        data["available"] = False
-
-    def _get_device_data(self, dev_id: str) -> DeviceData:
-        """Helper-function for _all_device_data() and async_update().
-
-        Provide device-data, based on Location ID (= dev_id), from APPLIANCES.
-        """
-        device = self.gw_devices[dev_id]
-        data = self._get_measurement_data(dev_id)
-
-        # Check availability of wired-connected devices
-        # Smartmeter
-        self._check_availability(
-            device, "smartmeter", data, "P1 does not seem to be connected"
-        )
-        # OpenTherm device
-        if device["name"] != "OnOff":
-            self._check_availability(
-                device, "heater_central", data, "no OpenTherm communication"
-            )
-
-        # Switching groups data
-        self._device_data_switching_group(device, data)
-        # Adam data
-        self._device_data_adam(device, data)
-        # Skip obtaining data for non master-thermostats
-        if device["dev_class"] not in ZONE_THERMOSTATS:
-            return data
-
-        # Thermostat data (presets, temperatures etc)
-        self._device_data_climate(device, data)
-
-        return data