plugwise 1.5.2__py3-none-any.whl → 1.6.1__py3-none-any.whl

plugwise/__init__.py

@@ -69,6 +69,7 @@ class Smile(SmileComm):
         self._elga = False
         self._is_thermostat = False
         self._last_active: dict[str, str | None] = {}
+        self._loc_data: dict[str, ThermoLoc] = {}
         self._on_off_device = False
         self._opentherm_device = False
         self._schedule_old_states: dict[str, dict[str, str]] = {}
@@ -76,7 +77,6 @@ class Smile(SmileComm):
         self._stretch_v2 = False
         self._target_smile: str = NONE
         self.gateway_id: str = NONE
-        self.loc_data: dict[str, ThermoLoc] = {}
         self.smile_fw_version: Version | None = None
         self.smile_hostname: str = NONE
         self.smile_hw_version: str | None = None
@@ -134,11 +134,11 @@ class Smile(SmileComm):
             self._elga,
             self._is_thermostat,
             self._last_active,
+            self._loc_data,
             self._on_off_device,
             self._opentherm_device,
             self._schedule_old_states,
             self.gateway_id,
-            self.loc_data,
             self.smile_fw_version,
             self.smile_hostname,
             self.smile_hw_version,
@@ -155,11 +155,11 @@ class Smile(SmileComm):
             self._request,
             self._websession,
             self._is_thermostat,
+            self._loc_data,
             self._on_off_device,
             self._opentherm_device,
             self._stretch_v2,
             self._target_smile,
-            self.loc_data,
             self.smile_fw_version,
             self.smile_hostname,
             self.smile_hw_version,
@@ -173,7 +173,7 @@ class Smile(SmileComm):
         )
 
         # Update all endpoints on first connect
-        await self._smile_api.full_update_device()
+        await self._smile_api.full_xml_update()
 
         return self.smile_version
 
@@ -298,17 +298,17 @@ class Smile(SmileComm):
         self.smile_legacy = True
         return return_model
 
-    async def full_update_device(self) -> None:
+    async def full_xml_update(self) -> None:
         """Helper-function used for testing."""
-        await self._smile_api.full_update_device()
+        await self._smile_api.full_xml_update()
 
-    def get_all_devices(self) -> None:
+    def get_all_gateway_entities(self) -> None:
         """Helper-function used for testing."""
-        self._smile_api.get_all_devices()
+        self._smile_api.get_all_gateway_entities()
 
     async def async_update(self) -> PlugwiseData:
-        """Perform an incremental update for updating the various device states."""
-        data = PlugwiseData({}, {})
+        """Update the various entities and their states."""
+        data = PlugwiseData(devices={}, gateway={})
         try:
             data = await self._smile_api.async_update()
             self.gateway_id = data.gateway["gateway_id"]

plugwise/common.py

@@ -11,8 +11,8 @@ from plugwise.constants import (
     SPECIAL_PLUG_TYPES,
     SWITCH_GROUP_TYPES,
     ApplianceType,
-    DeviceData,
-    ModelData,
+    GwEntityData,
+    ModuleData,
     SensorType,
 )
 from plugwise.util import (
@@ -40,7 +40,7 @@ class SmileCommon:
         self._heater_id: str
         self._on_off_device: bool
         self._opentherm_device: bool
-        self.gw_devices: dict[str, DeviceData]
+        self.gw_entities: dict[str, GwEntityData]
         self.smile_name: str
         self.smile_type: str
 
@@ -108,7 +108,7 @@ class SmileCommon:
 
         return appl
 
-    def _collect_power_values(self, data: DeviceData, loc: Munch, tariff: str, legacy: bool = False) -> None:
+    def _collect_power_values(self, data: GwEntityData, loc: Munch, tariff: str, legacy: bool = False) -> None:
         """Something."""
         for loc.peak_select in ("nl_peak", "nl_offpeak"):
             loc.locator = (
@@ -131,6 +131,19 @@ class SmileCommon:
             key = cast(SensorType, loc.key_string)
             data["sensors"][key] = loc.f_val
 
+    def _count_data_items(self, data: GwEntityData) -> None:
+        """When present, count the binary_sensors, sensors and switches dict-items, don't count the dicts.
+
+        Also, count the remaining single data items, the amount of dicts present have already been pre-subtracted in the previous step.
+        """
+        if "binary_sensors" in data:
+            self._count += len(data["binary_sensors"]) - 1
+        if "sensors" in data:
+            self._count += len(data["sensors"]) - 1
+        if "switches" in data:
+            self._count += len(data["switches"]) - 1
+        self._count += len(data)
+
     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
@@ -160,8 +173,8 @@ class SmileCommon:
         measurement: str,
         net_string: SensorType,
         f_val: float | int,
-        direct_data: DeviceData,
-    ) -> DeviceData:
+        data: GwEntityData,
+    ) -> GwEntityData:
         """Calculate differential energy."""
         if (
             "electricity" in measurement
@@ -171,10 +184,10 @@ class SmileCommon:
             diff = 1
             if "produced" in measurement:
                 diff = -1
-            if net_string not in direct_data["sensors"]:
+            if net_string not in data["sensors"]:
                 tmp_val: float | int = 0
             else:
-                tmp_val = direct_data["sensors"][net_string]
+                tmp_val = data["sensors"][net_string]
 
             if isinstance(f_val, int):
                 tmp_val += f_val * diff
@@ -182,13 +195,13 @@ class SmileCommon:
                 tmp_val += float(f_val * diff)
                 tmp_val = float(f"{round(tmp_val, 3):.3f}")
 
-            direct_data["sensors"][net_string] = tmp_val
+            data["sensors"][net_string] = tmp_val
 
-        return direct_data
+        return 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}
+    def _create_gw_entities(self, appl: Munch) -> None:
+        """Helper-function for creating/updating gw_entities."""
+        self.gw_entities[appl.entity_id] = {"dev_class": appl.pwclass}
         self._count += 1
         for key, value in {
             "available": appl.available,
@@ -204,30 +217,30 @@ class SmileCommon:
         }.items():
             if value is not None or key == "location":
                 appl_key = cast(ApplianceType, key)
-                self.gw_devices[appl.dev_id][appl_key] = value
+                self.gw_entities[appl.entity_id][appl_key] = value
                 self._count += 1
 
-    def _device_data_switching_group(
-        self, device: DeviceData, data: DeviceData
+    def _entity_switching_group(
+        self, entity: GwEntityData, data: GwEntityData
     ) -> None:
-        """Helper-function for _get_device_data().
+        """Helper-function for _get_device_zone_data().
 
         Determine switching group device data.
         """
-        if device["dev_class"] in SWITCH_GROUP_TYPES:
+        if entity["dev_class"] in SWITCH_GROUP_TYPES:
             counter = 0
-            for member in device["members"]:
-                if self.gw_devices[member]["switches"].get("relay"):
+            for member in entity["members"]:
+                if self.gw_entities[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().
+    def _get_group_switches(self) -> dict[str, GwEntityData]:
+        """Helper-function for smile.py: get_all_gateway_entities().
 
         Collect switching- or pump-group info.
         """
-        switch_groups: dict[str, DeviceData] = {}
+        switch_groups: dict[str, GwEntityData] = {}
         # P1 and Anna don't have switchgroups
         if self.smile_type == "power" or self.smile(ANNA):
             return switch_groups
@@ -240,25 +253,22 @@ class SmileCommon:
             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:
+                if item.attrib["id"] in self.gw_entities:
                     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,
-                        },
-                    },
-                )
+                switch_groups[group_id] = {
+                    "dev_class": group_type,
+                    "model": "Switchgroup",
+                    "name": group_name,
+                    "members": members,
+                    "vendor": "Plugwise",
+                }
                 self._count += 4
 
         return switch_groups
 
-    def _get_lock_state(self, xml: etree, data: DeviceData, stretch_v2: bool = False) -> None:
+    def _get_lock_state(self, xml: etree, data: GwEntityData, stretch_v2: bool = False) -> None:
         """Helper-function for _get_measurement_data().
 
         Adam & Stretches: obtain the relay-switch lock state.
@@ -280,12 +290,12 @@ class SmileCommon:
         locator: str,
         xml_2: etree = None,
         legacy: bool = False,
-    ) -> ModelData:
+    ) -> ModuleData:
         """Helper-function for _energy_device_info_finder() and _appliance_info_finder().
 
         Collect requested info from MODULES.
         """
-        model_data: ModelData = {
+        module_data: ModuleData = {
             "contents": False,
             "firmware_version": None,
             "hardware_version": None,
@@ -304,25 +314,25 @@ class SmileCommon:
             search = return_valid(xml_2, self._domain_objects)
             module = search.find(loc)
             if module is not None:  # pylint: disable=consider-using-assignment-expr
-                model_data["contents"] = True
-                get_vendor_name(module, model_data)
-                model_data["vendor_model"] = module.find("vendor_model").text
-                model_data["hardware_version"] = module.find("hardware_version").text
-                model_data["firmware_version"] = module.find("firmware_version").text
-                self._get_zigbee_data(module, model_data, legacy)
+                module_data["contents"] = True
+                get_vendor_name(module, module_data)
+                module_data["vendor_model"] = module.find("vendor_model").text
+                module_data["hardware_version"] = module.find("hardware_version").text
+                module_data["firmware_version"] = module.find("firmware_version").text
+                self._get_zigbee_data(module, module_data, legacy)
 
-        return model_data
+        return module_data
 
-    def _get_zigbee_data(self, module: etree, model_data: ModelData, legacy: bool) -> None:
-        """Helper-function for _get_model_data()."""
+    def _get_zigbee_data(self, module: etree, module_data: ModuleData, legacy: bool) -> None:
+        """Helper-function for _get_module_data()."""
         if legacy:
             # Stretches
             if (router := module.find("./protocols/network_router")) is not None:
-                model_data["zigbee_mac_address"] = router.find("mac_address").text
+                module_data["zigbee_mac_address"] = router.find("mac_address").text
             # Also look for the Circle+/Stealth M+
             if (coord := module.find("./protocols/network_coordinator")) is not None:
-                model_data["zigbee_mac_address"] = coord.find("mac_address").text
+                module_data["zigbee_mac_address"] = coord.find("mac_address").text
         # Adam
         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"
+                module_data["zigbee_mac_address"] = zb_node.find("mac_address").text
+                module_data["reachable"] = zb_node.find("reachable").text == "true"

plugwise/constants.py

@@ -190,6 +190,14 @@ OBSOLETE_MEASUREMENTS: Final[tuple[str, ...]] = (
     "outdoor_temperature",
 )
 
+# Zone/climate related measurements
+ZONE_MEASUREMENTS: Final[dict[str, DATA | UOM]] = {
+    "electricity_consumed": UOM(POWER_WATT),
+    "electricity_produced": UOM(POWER_WATT),
+    "relay": UOM(NONE),
+    "temperature": UOM(TEMP_CELSIUS),  # HA Core thermostat current_temperature
+}
+
 # Literals
 SMILE_P1 = "Smile P1"
 POWER = "power"
@@ -397,8 +405,8 @@ class GatewayData(TypedDict, total=False):
     smile_name: str
 
 
-class ModelData(TypedDict):
-    """The ModelData class."""
+class ModuleData(TypedDict):
+    """The Module data class."""
 
     contents: bool
     firmware_version: str | None
@@ -492,9 +500,9 @@ class ThermoLoc(TypedDict, total=False):
     """Thermo Location class."""
 
     name: str
-    primary: str | None
+    primary: list[str]
     primary_prio: int
-    secondary: set[str]
+    secondary: list[str]
 
 
 class ActuatorData(TypedDict, total=False):
@@ -508,8 +516,11 @@ class ActuatorData(TypedDict, total=False):
     upper_bound: float
 
 
-class DeviceData(TypedDict, total=False):
-    """The Device Data class, covering the collected and ordered output-data per device."""
+class GwEntityData(TypedDict, total=False):
+    """The Gateway Entity data class.
+
+    Covering the collected output-data per device or location.
+    """
 
     # Appliance base data
     dev_class: str
@@ -544,13 +555,13 @@ class DeviceData(TypedDict, total=False):
     select_gateway_mode: str
     select_regulation_mode: str
 
-    # Master Thermostats
+    # Thermostat-related
+    thermostats: dict[str, list[str]]
     # Presets:
     active_preset: str | None
     preset_modes: list[str] | None
     # Schedules:
     available_schedules: list[str]
-    last_used: str | None
     select_schedule: str
 
     climate_mode: str
@@ -571,5 +582,6 @@ class DeviceData(TypedDict, total=False):
 class PlugwiseData:
     """Plugwise data provided as output."""
 
+    devices: dict[str, GwEntityData]
     gateway: GatewayData
-    devices: dict[str, DeviceData]
+

plugwise/data.py

@@ -13,9 +13,8 @@ from plugwise.constants import (
     MIN_SETPOINT,
     NONE,
     OFF,
-    ZONE_THERMOSTATS,
     ActuatorData,
-    DeviceData,
+    GwEntityData,
 )
 from plugwise.helper import SmileHelper
 from plugwise.util import remove_empty_platform_dicts
@@ -29,12 +28,16 @@ class SmileData(SmileHelper):
         SmileHelper.__init__(self)
 
 
-    def _all_device_data(self) -> None:
-        """Helper-function for get_all_devices().
+    def _all_entity_data(self) -> None:
+        """Helper-function for get_all_gateway_entities().
 
-        Collect data for each device and add to self.gw_data and self.gw_devices.
+        Collect data for each entity and add to self.gw_data and self.gw_entities.
         """
-        self._update_gw_devices()
+        self._update_gw_entities()
+        if self.smile(ADAM):
+            self._update_zones()
+            self.gw_entities.update(self._zones)
+
         self.gw_data.update(
             {
                 "gateway_id": self.gateway_id,
@@ -49,31 +52,40 @@ class SmileData(SmileHelper):
                 {"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().
+    def _update_zones(self) -> None:
+        """Helper-function for _all_entity_data() and async_update().
+
+        Collect data for each zone/location and add to self._zones.
+        """
+        for location_id, zone in self._zones.items():
+            data = self._get_location_data(location_id)
+            zone.update(data)
+
+    def _update_gw_entities(self) -> None:
+        """Helper-function for _all_entities_data() and async_update().
 
-        Collect data for each device and add to self.gw_devices.
+        Collect data for each entity and add to self.gw_entities.
         """
         mac_list: list[str] = []
-        for device_id, device in self.gw_devices.items():
-            data = self._get_device_data(device_id)
-            if device_id == self.gateway_id:
+        for entity_id, entity in self.gw_entities.items():
+            data = self._get_entity_data(entity_id)
+            if entity_id == self.gateway_id:
                 mac_list = self._detect_low_batteries()
-                self._add_or_update_notifications(device_id, device, data)
+                self._add_or_update_notifications(entity_id, entity, data)
 
-            device.update(data)
+            entity.update(data)
             is_battery_low = (
                 mac_list
-                and "low_battery" in device["binary_sensors"]
-                and device["zigbee_mac_address"] in mac_list
-                and device["dev_class"] in ("thermo_sensor", "thermostatic_radiator_valve", "zone_thermometer", "zone_thermostat")
+                and "low_battery" in entity["binary_sensors"]
+                and entity["zigbee_mac_address"] in mac_list
+                and entity["dev_class"] in ("thermo_sensor", "thermostatic_radiator_valve", "zone_thermometer", "zone_thermostat")
             )
             if is_battery_low:
-                device["binary_sensors"]["low_battery"] = True
+                entity["binary_sensors"]["low_battery"] = True
 
-            self._update_for_cooling(device)
+            self._update_for_cooling(entity)
 
-            remove_empty_platform_dicts(device)
+            remove_empty_platform_dicts(entity)
 
     def _detect_low_batteries(self) -> list[str]:
         """Helper-function updating the low-battery binary_sensor status from a Battery-is-low message."""
@@ -97,31 +109,31 @@ class SmileData(SmileHelper):
         return mac_address_list
 
     def _add_or_update_notifications(
-        self, device_id: str, device: DeviceData, data: DeviceData
+        self, entity_id: str, entity: GwEntityData, data: GwEntityData
     ) -> None:
         """Helper-function adding or updating the Plugwise notifications."""
         if (
-            device_id == self.gateway_id
+            entity_id == self.gateway_id
             and (
                 self._is_thermostat or self.smile_type == "power"
             )
         ) or (
-            "binary_sensors" in device
-            and "plugwise_notification" in device["binary_sensors"]
+            "binary_sensors" in entity
+            and "plugwise_notification" in entity["binary_sensors"]
         ):
             data["binary_sensors"]["plugwise_notification"] = bool(self._notifications)
             self._count += 1
 
-    def _update_for_cooling(self, device: DeviceData) -> None:
+    def _update_for_cooling(self, entity: GwEntityData) -> None:
         """Helper-function for adding/updating various cooling-related values."""
         # For Anna and heating + cooling, replace setpoint with setpoint_high/_low
         if (
             self.smile(ANNA)
             and self._cooling_present
-            and device["dev_class"] == "thermostat"
+            and entity["dev_class"] == "thermostat"
         ):
-            thermostat = device["thermostat"]
-            sensors = device["sensors"]
+            thermostat = entity["thermostat"]
+            sensors = entity["sensors"]
             temp_dict: ActuatorData = {
                 "setpoint_low": thermostat["setpoint"],
                 "setpoint_high": MAX_SETPOINT,
@@ -133,53 +145,68 @@ class SmileData(SmileHelper):
                 }
             thermostat.pop("setpoint")
             temp_dict.update(thermostat)
-            device["thermostat"] = temp_dict
+            entity["thermostat"] = temp_dict
             if "setpoint" in sensors:
                 sensors.pop("setpoint")
             sensors["setpoint_low"] = temp_dict["setpoint_low"]
             sensors["setpoint_high"] = temp_dict["setpoint_high"]
-            self._count += 2
+            self._count += 2  # add 4, remove 2
+
+
+    def _get_location_data(self, loc_id: str) -> GwEntityData:
+        """Helper-function for _all_entity_data() and async_update().
+
+        Provide entity-data, based on Location ID (= loc_id).
+        """
+        zone = self._zones[loc_id]
+        data = self._get_zone_data(loc_id)
+        if ctrl_state := self._control_state(loc_id):
+            data["control_state"] = ctrl_state
+            self._count += 1
 
-    def _get_device_data(self, dev_id: str) -> DeviceData:
-        """Helper-function for _all_device_data() and async_update().
+        # Thermostat data (presets, temperatures etc)
+        self._climate_data(loc_id, zone, data)
+
+        return data
 
-        Provide device-data, based on Location ID (= dev_id), from APPLIANCES.
+    def _get_entity_data(self, entity_id: str) -> GwEntityData:
+        """Helper-function for _update_gw_entities() and async_update().
+
+        Provide entity-data, based on appliance_id (= entity_id).
         """
-        device = self.gw_devices[dev_id]
-        data = self._get_measurement_data(dev_id)
+        entity = self.gw_entities[entity_id]
+        data = self._get_measurement_data(entity_id)
 
-        # Check availability of wired-connected devices
+        # Check availability of wired-connected entities
         # Smartmeter
         self._check_availability(
-            device, "smartmeter", data, "P1 does not seem to be connected"
+            entity, "smartmeter", data, "P1 does not seem to be connected"
         )
-        # OpenTherm device
-        if device["name"] != "OnOff":
+        # OpenTherm entity
+        if entity["name"] != "OnOff":
             self._check_availability(
-                device, "heater_central", data, "no OpenTherm communication"
+                entity, "heater_central", data, "no OpenTherm communication"
             )
 
         # Switching groups data
-        self._device_data_switching_group(device, data)
+        self._entity_switching_group(entity, 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
+        self._get_adam_data(entity, data)
 
-        # Thermostat data (presets, temperatures etc)
-        self._device_data_climate(device, data)
+        # Thermostat data for Anna (presets, temperatures etc)
+        if self.smile(ANNA) and entity["dev_class"] == "thermostat":
+            self._climate_data(entity_id, entity, data)
 
         return data
 
     def _check_availability(
-        self, device: DeviceData, dev_class: str, data: DeviceData, message: str
+        self, entity: GwEntityData, dev_class: str, data: GwEntityData, message: str
     ) -> None:
-        """Helper-function for _get_device_data().
+        """Helper-function for _get_entity_data().
 
-        Provide availability status for the wired-commected devices.
+        Provide availability status for the wired-connected devices.
         """
-        if device["dev_class"] == dev_class:
+        if entity["dev_class"] == dev_class:
             data["available"] = True
             self._count += 1
             for item in self._notifications.values():
@@ -187,8 +214,8 @@ class SmileData(SmileHelper):
                     if message in msg:
                         data["available"] = False
 
-    def _device_data_adam(self, device: DeviceData, data: DeviceData) -> None:
-        """Helper-function for _get_device_data().
+    def _get_adam_data(self, entity: GwEntityData, data: GwEntityData) -> None:
+        """Helper-function for _get_entity_data().
 
         Determine Adam heating-status for on-off heating via valves,
         available regulations_modes and thermostat control_states.
@@ -196,14 +223,14 @@ class SmileData(SmileHelper):
         if self.smile(ADAM):
             # Indicate heating_state based on valves being open in case of city-provided heating
             if (
-                device["dev_class"] == "heater_central"
+                entity["dev_class"] == "heater_central"
                 and self._on_off_device
                 and isinstance(self._heating_valves(), int)
             ):
                 data["binary_sensors"]["heating_state"] = self._heating_valves() != 0
 
             # Show the allowed regulation_modes and gateway_modes
-            if device["dev_class"] == "gateway":
+            if entity["dev_class"] == "gateway":
                 if self._reg_allowed_modes:
                     data["regulation_modes"] = self._reg_allowed_modes
                     self._count += 1
@@ -211,19 +238,20 @@ class SmileData(SmileHelper):
                     data["gateway_modes"] = self._gw_allowed_modes
                     self._count += 1
 
-            # 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):
-                    data["control_state"] = ctrl_state
-                    self._count += 1
 
-    def _device_data_climate(self, device: DeviceData, data: DeviceData) -> None:
-        """Helper-function for _get_device_data().
+    def _climate_data(
+        self,
+        location_id: str,
+        entity: GwEntityData,
+        data: GwEntityData
+    ) -> None:
+        """Helper-function for _get_entity_data().
 
-        Determine climate-control device data.
+        Determine climate-control entity data.
         """
-        loc_id = device["location"]
+        loc_id = location_id
+        if entity.get("location") is not None:
+            loc_id = entity["location"]
 
         # Presets
         data["preset_modes"] = None
@@ -258,13 +286,13 @@ class SmileData(SmileHelper):
 
     def check_reg_mode(self, mode: str) -> bool:
         """Helper-function for device_data_climate()."""
-        gateway = self.gw_devices[self.gateway_id]
+        gateway = self.gw_entities[self.gateway_id]
         return (
             "regulation_modes" in gateway and gateway["select_regulation_mode"] == mode
         )
 
     def _get_schedule_states_with_off(
-        self, location: str, schedules: list[str], selected: str, data: DeviceData
+        self, location: str, schedules: list[str], selected: str, data: GwEntityData
     ) -> None:
         """Collect schedules with states for each thermostat.