Refactor control example and display cooling info

Make get_attribute and the print helpers synchronous (they no longer
await), reduce repetition, and show cooling details: mode changeover,
heating/cooling setpoints in device state and separate heating/cooling
bounds in static state.

Author: liudger

examples/control.py

@@ -35,7 +35,7 @@
 from discovery import get_bsblan_host, get_config_from_env
 
 
-async def get_attribute(
+def get_attribute(
     attribute: Any, attr_type: str = "value", default: str = "N/A"
 ) -> str:
     """Safely retrieve the desired property ('value' or 'desc') of an attribute.
@@ -103,16 +103,16 @@ def get_hvac_action_name(status_code: int) -> str:
     return category.name.lower()
 
 
-async def print_state(state: State) -> None:
+def print_state(state: State) -> None:
     """Print the current state of the BSBLan device.
 
     Args:
         state (State): The current state of the BSBLan device.
 
     """
     # Get the HVAC action - both the raw value and mapped action name
-    hvac_action_desc = await get_attribute(state.hvac_action, "desc", "Unknown Action")
-    hvac_action_value = await get_attribute(state.hvac_action, "value", "N/A")
+    hvac_action_desc = get_attribute(state.hvac_action, "desc", "Unknown Action")
+    hvac_action_value = get_attribute(state.hvac_action, "value", "N/A")
 
     # Map the raw status code to a simplified action name using the new enum approach
     hvac_action_mapped = "N/A"
@@ -133,63 +133,56 @@ async def print_state(state: State) -> None:
         "HVAC Action (device desc)": hvac_action_desc,
         "HVAC Action (status name)": status_name,
         "HVAC Action (category)": hvac_action_mapped,
-        "HVAC Mode": await get_attribute(state.hvac_mode, "desc", "Unknown Mode"),
-        "Current Temperature": await get_attribute(
-            state.current_temperature, "value", "N/A"
-        ),
+        "HVAC Mode": get_attribute(state.hvac_mode, "desc", "Unknown Mode"),
+        "Mode Changeover": get_attribute(state.hvac_mode_changeover, "desc"),
+        "Target Temperature (heating)": get_attribute(state.target_temperature),
+        "Cooling Setpoint (target high)": get_attribute(state.target_temperature_high),
+        "Current Temperature": get_attribute(state.current_temperature),
     }
     print_attributes("Device State", attributes)
 
 
-async def print_sensor(sensor: Sensor) -> None:
+def print_sensor(sensor: Sensor) -> None:
     """Print sensor information from the BSBLan device.
 
     Args:
         sensor (Sensor): The sensor information from the BSBLan device.
 
     """
     attributes = {
-        "Outside Temperature": await get_attribute(
-            sensor.outside_temperature, "value", "N/A"
-        ),
-        "Current Temperature": await get_attribute(
-            sensor.current_temperature, "value", "N/A"
-        ),
+        "Outside Temperature": get_attribute(sensor.outside_temperature),
+        "Current Temperature": get_attribute(sensor.current_temperature),
     }
     print_attributes("Sensor Information", attributes)
 
 
-async def print_device_time(device_time: DeviceTime) -> None:
+def print_device_time(device_time: DeviceTime) -> None:
     """Print device time information.
 
     Args:
         device_time (DeviceTime): The device time information from the BSBLan device.
 
     """
     attributes = {
-        "Current Time": await get_attribute(device_time.time, "value", "N/A"),
-        "Time Unit": await get_attribute(device_time.time, "unit", "N/A"),
-        "Time Description": await get_attribute(device_time.time, "desc", "N/A"),
+        "Current Time": get_attribute(device_time.time, "value"),
+        "Time Unit": get_attribute(device_time.time, "unit"),
+        "Time Description": get_attribute(device_time.time, "desc"),
     }
     print_attributes("Device Time", attributes)
 
 
-async def print_device_info(device: Device, info: Info) -> None:
+def print_device_info(device: Device, info: Info) -> None:
     """Print device and general information.
 
     Args:
         device (Device): The device information from the BSBLan device.
         info (Info): The general information from the BSBLan device.
 
     """
-    device_identification = await get_attribute(
-        info.device_identification, "value", "N/A"
-    )
-
     attributes = {
         "Device Name": device.name or "N/A",
         "Version": device.version or "N/A",
-        "Device Identification": device_identification,
+        "Device Identification": get_attribute(info.device_identification),
         "Bus Type": format_optional(device.bus),
         "Bus Writable Flag": format_optional(device.buswritable),
         "Bus Address": format_optional(device.busaddr),
@@ -199,26 +192,31 @@ async def print_device_info(device: Device, info: Info) -> None:
     print_attributes("Device Information", attributes)
 
 
-async def print_static_state(static_state: StaticState) -> None:
-    """Print static state information.
+def print_static_state(static_state: StaticState) -> None:
+    """Print static state information, including heating and cooling bounds.
 
     Args:
         static_state (StaticState): The static state information from the BSBLan device.
 
     """
-    min_temp = await get_attribute(static_state.min_temp, "value", "N/A")
-    max_temp = await get_attribute(static_state.max_temp, "value", "N/A")
-    min_temp_unit = await get_attribute(static_state.min_temp, "unit", "N/A")
-
     attributes = {
-        "Min Temperature": min_temp,
-        "Max Temperature": max_temp,
-        "Min Temperature Unit": min_temp_unit,
+        "Min Temperature (heating)": get_attribute(static_state.min_temp),
+        "Max Temperature (heating)": get_attribute(static_state.max_temp),
+        "Heating Protective Setpoint": get_attribute(
+            static_state.heating_protective_setpoint
+        ),
+        "Cooling Setpoint Min": get_attribute(
+            static_state.cooling_comfort_setpoint_min
+        ),
+        "Cooling Setpoint Max (reduced)": get_attribute(
+            static_state.cooling_reduced_setpoint
+        ),
+        "Temperature Unit": get_attribute(static_state.min_temp, "unit"),
     }
     print_attributes("Static State", attributes)
 
 
-async def print_hot_water_state(hot_water_state: HotWaterState) -> None:
+def print_hot_water_state(hot_water_state: HotWaterState) -> None:
     """Print essential hot water state information.
 
     Args:
@@ -227,24 +225,20 @@ async def print_hot_water_state(hot_water_state: HotWaterState) -> None:
 
     """
     attributes = {
-        "Operating Mode": await get_attribute(
+        "Operating Mode": get_attribute(
             hot_water_state.operating_mode, "desc", "Unknown Mode"
         ),
-        "Nominal Setpoint": await get_attribute(
-            hot_water_state.nominal_setpoint, "value", "N/A"
-        ),
-        "Release": await get_attribute(hot_water_state.release, "desc", "N/A"),
-        "Current Temperature": await get_attribute(
-            hot_water_state.dhw_actual_value_top_temperature, "value", "N/A"
-        ),
-        "DHW Pump State": await get_attribute(
-            hot_water_state.state_dhw_pump, "desc", "N/A"
+        "Nominal Setpoint": get_attribute(hot_water_state.nominal_setpoint),
+        "Release": get_attribute(hot_water_state.release, "desc"),
+        "Current Temperature": get_attribute(
+            hot_water_state.dhw_actual_value_top_temperature
         ),
+        "DHW Pump State": get_attribute(hot_water_state.state_dhw_pump, "desc"),
     }
     print_attributes("Hot Water State (Essential)", attributes)
 
 
-async def print_hot_water_config(hot_water_config: HotWaterConfig) -> None:
+def print_hot_water_config(hot_water_config: HotWaterConfig) -> None:
     """Print hot water configuration information.
 
     Args:
@@ -253,65 +247,53 @@ async def print_hot_water_config(hot_water_config: HotWaterConfig) -> None:
 
     """
     attributes = {
-        "Nominal Setpoint Max": await get_attribute(
-            hot_water_config.nominal_setpoint_max, "value", "N/A"
-        ),
-        "Reduced Setpoint": await get_attribute(
-            hot_water_config.reduced_setpoint, "value", "N/A"
+        "Nominal Setpoint Max": get_attribute(hot_water_config.nominal_setpoint_max),
+        "Reduced Setpoint": get_attribute(hot_water_config.reduced_setpoint),
+        "Legionella Function": get_attribute(
+            hot_water_config.legionella_function, "desc"
         ),
-        "Legionella Function": await get_attribute(
-            hot_water_config.legionella_function, "desc", "N/A"
+        "Legionella Setpoint": get_attribute(
+            hot_water_config.legionella_function_setpoint
         ),
-        "Legionella Setpoint": await get_attribute(
-            hot_water_config.legionella_function_setpoint, "value", "N/A"
+        "Legionella Periodicity": get_attribute(
+            hot_water_config.legionella_function_periodicity
         ),
-        "Legionella Periodicity": await get_attribute(
-            hot_water_config.legionella_function_periodicity, "value", "N/A"
+        "Circulation Pump Release": get_attribute(
+            hot_water_config.dhw_circulation_pump_release, "desc"
         ),
-        "Circulation Pump Release": await get_attribute(
-            hot_water_config.dhw_circulation_pump_release, "desc", "N/A"
-        ),
-        "Circulation Setpoint": await get_attribute(
-            hot_water_config.dhw_circulation_setpoint, "value", "N/A"
+        "Circulation Setpoint": get_attribute(
+            hot_water_config.dhw_circulation_setpoint
         ),
     }
     print_attributes("Hot Water Configuration", attributes)
 
 
-async def print_hot_water_schedule(hot_water_schedule: HotWaterSchedule) -> None:
+def print_hot_water_schedule(hot_water_schedule: HotWaterSchedule) -> None:
     """Print hot water schedule information.
 
     Args:
         hot_water_schedule (HotWaterSchedule): The hot water schedule information
             from the BSBLan device (time programs).
 
     """
+    days = (
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+        "sunday",
+    )
     attributes = {
-        "Monday": await get_attribute(
-            hot_water_schedule.dhw_time_program_monday, "value", "N/A"
-        ),
-        "Tuesday": await get_attribute(
-            hot_water_schedule.dhw_time_program_tuesday, "value", "N/A"
-        ),
-        "Wednesday": await get_attribute(
-            hot_water_schedule.dhw_time_program_wednesday, "value", "N/A"
-        ),
-        "Thursday": await get_attribute(
-            hot_water_schedule.dhw_time_program_thursday, "value", "N/A"
-        ),
-        "Friday": await get_attribute(
-            hot_water_schedule.dhw_time_program_friday, "value", "N/A"
-        ),
-        "Saturday": await get_attribute(
-            hot_water_schedule.dhw_time_program_saturday, "value", "N/A"
-        ),
-        "Sunday": await get_attribute(
-            hot_water_schedule.dhw_time_program_sunday, "value", "N/A"
-        ),
-        "Standard Values": await get_attribute(
-            hot_water_schedule.dhw_time_program_standard_values, "value", "N/A"
-        ),
+        day.capitalize(): get_attribute(
+            getattr(hot_water_schedule, f"dhw_time_program_{day}")
+        )
+        for day in days
     }
+    attributes["Standard Values"] = get_attribute(
+        hot_water_schedule.dhw_time_program_standard_values
+    )
     print_attributes("Hot Water Schedule", attributes)
 
 
@@ -337,11 +319,11 @@ async def main() -> None:
         # Get and print device and general info, including bus metadata
         device: Device = bsblan.device_info or await bsblan.device()
         info: Info = await bsblan.info()
-        await print_device_info(device, info)
+        print_device_info(device, info)
 
         # Get and print state
         state: State = await bsblan.state()
-        await print_state(state)
+        print_state(state)
 
         # Set thermostat temperature
         print("\nSetting temperature to 18°C")
@@ -353,34 +335,34 @@ async def main() -> None:
 
         # Get and print sensor information
         sensor: Sensor = await bsblan.sensor()
-        await print_sensor(sensor)
+        print_sensor(sensor)
 
         # Get and print device time
         if bsblan.supports_time_sync:
             device_time: DeviceTime = await bsblan.time()
-            await print_device_time(device_time)
+            print_device_time(device_time)
         else:
             print("\nDevice time is not available for this bus type")
 
         # Get and print static state
         static_state: StaticState = await bsblan.static_values()
-        await print_static_state(static_state)
+        print_static_state(static_state)
 
         # Get hot water state (essential parameters for frequent polling)
         hot_water_state: HotWaterState = await bsblan.hot_water_state()
-        await print_hot_water_state(hot_water_state)
+        print_hot_water_state(hot_water_state)
 
         # Get hot water configuration (checked less frequently)
         try:
             hot_water_config: HotWaterConfig = await bsblan.hot_water_config()
-            await print_hot_water_config(hot_water_config)
+            print_hot_water_config(hot_water_config)
         except Exception as e:  # noqa: BLE001 - Broad exception for demo purposes
             print(f"Hot water configuration not available: {e}")
 
         # Get hot water schedule (time programs)
         try:
             hot_water_schedule: HotWaterSchedule = await bsblan.hot_water_schedule()
-            await print_hot_water_schedule(hot_water_schedule)
+            print_hot_water_schedule(hot_water_schedule)
         except Exception as e:  # noqa: BLE001 - Broad exception for demo purposes
             print(f"Hot water schedule not available: {e}")