python-izone 1.3.11__tar.gz → 1.3.12__tar.gz

{python_izone-1.3.11 → python_izone-1.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-izone
-Version: 1.3.11
+Version: 1.3.12
 Summary: A python interface to the iZone airconditioner controller
 Project-URL: Homepage, https://github.com/Swamp-Ig/pizone
 Author-email: Penny Wood <pypl@ninjateaparty.com>

python_izone-1.3.12/docs/release-notes/v1.3.12.md

@@ -0,0 +1,23 @@
+# Release notes — v1.3.12
+
+**Compare range:** https://github.com/Swamp-Ig/pizone/compare/v1.3.11...v1.3.12
+
+## Since v1.3.11
+
+### V2 status data (new)
+
+- Every V2 zone and system key now reaches the cache, so `dump_state()` and diagnostics include the full payload. Nested system groups (`UnitOpt`, `Temperzone`, `GasHeat`) are flattened to dotted keys such as `UnitOpt.RA`. The `LockCode` and `Pass` secrets are dropped and never cached
+- New zone properties: `damper_position`, `damper_fault`, `sensor_fault`, `rf_signal`, `battery_level` and `sensor_type`, plus the `Zone.SensorType`, `Zone.RfSignal` and `Zone.BatteryLevel` enums. Each returns `None` when the bridge doesn't report it. `damper_fault` also works on V1
+- `BattVolt` is decoded as the vendor's battery-level enum (full / half / empty), not volts
+- Bridges without damper position feedback report a constant `DmpPos` of 50, so `damper_position` reads 50 on those units
+- New controller properties: `airflow_lock`, `airflow_min_lock` and `system_locked`, which work on V1 and V2. V2 lock flags are normalized to the V1 `AirflowLock` / `UnitLocked` values
+- New controller properties `indoor_humidity`, `indoor_tvoc` and `indoor_eco2`. These come from undocumented V2 keys (`InRh`, `InTVOC`, `IneCO2`), so their meaning and units are unverified
+
+### Fixes
+
+- A missing `CtrlZone` no longer falls back to zone 0. `zone_ctrl` is now `int | None`, and `control_setpoint_owner` returns `None` when it is unknown
+- `CtrlZone` 15 (unit setpoint, per the vendor header) now gives the unit ownership in every RAS mode, not only master
+
+### Maintenance
+
+- Dependency lock bumps: aiohttp 3.14.4, multidict 6.9.1

{python_izone-1.3.11 → python_izone-1.3.12}/pizone/controller.py

@@ -133,12 +133,13 @@ class Controller:
         "EcoMin": "15.0",
         "EcoMax": "30.0",
         "RAS": "zones",
-        "CtrlZone": 0,
         "NoOfZones": 0,
         "NoOfConst": 0,
         "SysType": "0",
         "FanAuto": "disabled",
     }
+    # Vendor header: CtrlZone 15 means the unit setpoint, not a zone.
+    _CTRL_ZONE_UNIT = 15
 
     def __init__(
         self,
@@ -693,6 +694,69 @@ class Controller:
         """Maximum temperature from eco lock, or 30 if eco lock is off."""
         return float(self._get_system_state("EcoMax")) if self.eco_lock else 30.0
 
+    @property
+    def airflow_lock(self) -> bool | None:
+        """True if zone maximum and minimum airflow are locked by the installer.
+
+        ``None`` if not reported.
+        """
+        match self._system_settings.get("AirflowLock"):
+            case "on":
+                return True
+            case "onMin" | "off":
+                return False
+            case _:
+                return None
+
+    @property
+    def airflow_min_lock(self) -> bool | None:
+        """True if zone minimum airflow is locked by the installer.
+
+        Also true when :attr:`airflow_lock` locks both. ``None`` if not reported.
+        """
+        match self._system_settings.get("AirflowLock"):
+            case "on" | "onMin":
+                return True
+            case "off":
+                return False
+            case _:
+                return None
+
+    @property
+    def system_locked(self) -> bool | None:
+        """True if the system is keycode locked, or ``None`` if not reported."""
+        match self._system_settings.get("UnitLocked"):
+            case "true":
+                return True
+            case "false":
+                return False
+            case _:
+                return None
+
+    @property
+    def indoor_humidity(self) -> int | None:
+        """Indoor relative humidity (V2 ``InRh``), or ``None`` if not reported.
+
+        Not in the vendor API documentation; meaning and units are unverified.
+        """
+        return self._int_system_state("InRh")
+
+    @property
+    def indoor_tvoc(self) -> int | None:
+        """Indoor TVOC (V2 ``InTVOC``), or ``None`` if not reported.
+
+        Not in the vendor API documentation; meaning and units are unverified.
+        """
+        return self._int_system_state("InTVOC")
+
+    @property
+    def indoor_eco2(self) -> int | None:
+        """Indoor equivalent CO2 (V2 ``IneCO2``), or ``None`` if not reported.
+
+        Not in the vendor API documentation; meaning and units are unverified.
+        """
+        return self._int_system_state("IneCO2")
+
     @property
     def ras_mode(self) -> str:
         """Return air sensor selection mode.
@@ -707,35 +771,43 @@ class Controller:
         return cast(str, self._get_system_state("RAS"))
 
     @property
-    def zone_ctrl(self) -> int:
-        """Zone index that currently controls the AC unit.
+    def zone_ctrl(self) -> int | None:
+        """Zone index that currently controls the AC unit, or ``None`` if not reported.
 
-        Value is interpreted in combination with :attr:`ras_mode`.
-        See :attr:`control_setpoint_owner` for the controller or zone that
-        owns the unit target.
+        Value is interpreted in combination with :attr:`ras_mode`; ``15`` means
+        the unit setpoint. See :attr:`control_setpoint_owner` for the controller
+        or zone that owns the unit target.
 
         Raises:
-            TypeError: If the cached value is missing or not numeric.
+            ValueError: If the cached value is not numeric.
 
         """
-        return int(self._get_system_state("CtrlZone"))
+        value = self._system_settings.get("CtrlZone")
+        return None if value is None else int(value)
 
     @property
     def control_setpoint_owner(self) -> Self | Zone | None:
         """Controller or zone that currently owns the unit setpoint.
 
-        Returns this controller when RAS mode is ``RAS``, when RAS mode is
-        ``master`` and :attr:`zone_ctrl` is past :attr:`zones_total` (the
-        indoor unit itself), or when any AUTO zone has no room sensor.
-        Otherwise the zone matching :attr:`zone_ctrl`, or ``None`` if that
-        index does not match a zone.
+        Returns this controller when RAS mode is ``RAS``, when :attr:`zone_ctrl`
+        is ``15`` (the unit setpoint), when RAS mode is ``master`` and
+        :attr:`zone_ctrl` is past :attr:`zones_total` (the indoor unit itself),
+        or when any AUTO zone has no room sensor. Otherwise the zone matching
+        :attr:`zone_ctrl`, or ``None`` if that index does not match a zone or
+        :attr:`zone_ctrl` is not reported.
 
         CONST/OPCL zones never have a room sensor; only a missing AUTO CTS
         forces unit control.
         """
+        zone_ctrl = self.zone_ctrl
         if (
             self.ras_mode == "RAS"
-            or (self.ras_mode == "master" and self.zone_ctrl > self.zones_total)
+            or zone_ctrl == self._CTRL_ZONE_UNIT
+            or (
+                self.ras_mode == "master"
+                and zone_ctrl is not None
+                and zone_ctrl > self.zones_total
+            )
             or any(
                 zone.type is Zone.Type.AUTO and zone.temp_current is None
                 for zone in self.zones
@@ -743,7 +815,7 @@ class Controller:
         ):
             return self
         return next(
-            (zone for zone in self.zones if zone.index == self.zone_ctrl),
+            (zone for zone in self.zones if zone.index == zone_ctrl),
             None,
         )
 
@@ -1041,6 +1113,12 @@ class Controller:
             and str(values["RAS"]) != "error"
         )
 
+    def _int_system_state(self, state: str) -> int | None:
+        value = self._system_settings.get(state)
+        if isinstance(value, bool) or not isinstance(value, int):
+            return None
+        return value
+
     def _get_system_state(self, state: str) -> DictValue:
         default = self._SYSTEM_STATE_DEFAULTS.get(state, "")
         value = self._system_settings.get(state)

{python_izone-1.3.11 → python_izone-1.3.12}/pizone/v2.py

@@ -53,6 +53,12 @@ _FAN_AUTO_TYPE = {
     3: "4-speed",
 }
 
+# V2 keys consumed under a different V1 name; everything else passes through.
+_ZONE_V2_NORMALIZED = frozenset({"ZoneType", "Setpoint"})
+_SYSTEM_V2_NORMALIZED = frozenset({"AirflowLock", "AirflowMinLock", "LockStatus"})
+# Never cache or dump these.
+_SYSTEM_V2_SECRETS = frozenset({"LockCode", "Pass"})
+
 
 class SysOnWire(IntEnum):
     """ASH SysOn_e."""
@@ -261,6 +267,39 @@ def _free_air_from_system(system_v2: dict[str, Any]) -> str:
     return "on" if int(system_v2.get("iSaveOn") or 0) else "off"
 
 
+def _locks_from_system(system_v2: dict[str, Any]) -> dict[str, str]:
+    """Translate V2 lock flags into V1 AirflowLock / UnitLocked values."""
+    locks: dict[str, str] = {}
+    if "AirflowLock" in system_v2 or "AirflowMinLock" in system_v2:
+        if int(system_v2.get("AirflowLock") or 0):
+            locks["AirflowLock"] = "on"
+        elif int(system_v2.get("AirflowMinLock") or 0):
+            locks["AirflowLock"] = "onMin"
+        else:
+            locks["AirflowLock"] = "off"
+    if "LockStatus" in system_v2:
+        locks["UnitLocked"] = "true" if int(system_v2["LockStatus"]) else "false"
+    return locks
+
+
+def _pass_through(
+    data: dict[str, str | int | float],
+    source: dict[str, Any],
+    *,
+    skip: frozenset[str],
+    prefix: str = "",
+) -> None:
+    """Copy scalar keys not already in *data*; flatten nested dicts to ``A.B``."""
+    for key, value in source.items():
+        name = f"{prefix}{key}"
+        if key in skip or name in data:
+            continue
+        if isinstance(value, dict):
+            _pass_through(data, value, skip=frozenset(), prefix=f"{name}.")
+        elif isinstance(value, (str, int, float)):
+            data[name] = value
+
+
 def system_v2_to_settings(
     system_v2: dict[str, Any], uid: str
 ) -> dict[str, str | int | float]:
@@ -309,7 +348,7 @@ def system_v2_to_settings(
 
     free_air = _free_air_from_system(system_v2)
 
-    return {
+    data: dict[str, str | int | float] = {
         "AirStreamDeviceUId": uid,
         "SysOn": on_val,
         "SysMode": mode_val,
@@ -319,7 +358,6 @@ def system_v2_to_settings(
         "Setpoint": temp_to_v1_str(system_v2.get("Setpoint")),
         "Temp": temp_to_v1_str(system_v2.get("Temp")),
         "RAS": ras_val,
-        "CtrlZone": int(system_v2.get("CtrlZone") or 0),
         "Tag1": str(system_v2.get("Tag1") or ""),
         "Tag2": str(system_v2.get("Tag2") or ""),
         "Warnings": str(system_v2.get("Warnings") or "none"),
@@ -333,6 +371,9 @@ def system_v2_to_settings(
         "FreeAir": free_air,
         "FanAuto": fan_auto,
     }
+    data.update(_locks_from_system(system_v2))
+    _pass_through(data, system_v2, skip=_SYSTEM_V2_NORMALIZED | _SYSTEM_V2_SECRETS)
+    return data
 
 
 def zones_v2_to_zone_data(zone_v2: dict[str, Any]) -> dict[str, str | int | float]:
@@ -368,19 +409,7 @@ def zones_v2_to_zone_data(zone_v2: dict[str, Any]) -> dict[str, str | int | floa
         "ConstA": int(zone_v2.get("ConstA") or 0),
         "Master": int(zone_v2.get("Master") or 0),
     }
-    for key in (
-        "DmpPos",
-        "RfSignal",
-        "BattVolt",
-        "SensorFault",
-        "DmpFlt",
-        "Bypass",
-        "SensType",
-        "Area",
-        "Rh",
-    ):
-        if key in zone_v2:
-            data[key] = zone_v2[key]
+    _pass_through(data, zone_v2, skip=_ZONE_V2_NORMALIZED)
     return data
 
 

{python_izone-1.3.11 → python_izone-1.3.12}/pizone/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.11'
-__version_tuple__ = version_tuple = (1, 3, 11)
+__version__ = version = '1.3.12'
+__version_tuple__ = version_tuple = (1, 3, 12)
 
 __commit_id__ = commit_id = None

{python_izone-1.3.11 → python_izone-1.3.12}/pizone/zone.py

@@ -3,6 +3,7 @@
 Properties for reading and setting zone data.
 """
 
+import builtins
 from enum import Enum
 from typing import TYPE_CHECKING, Any, cast
 
@@ -54,6 +55,31 @@ class Zone:
         CLOSE = "close"
         AUTO = "auto"
 
+    class SensorType(Enum):
+        """Zone temperature sensor type (V2 ``SensType``)."""
+
+        CCTS = 0
+        CSM = 1
+        ISENSE = 2
+        WIRELESS = 3
+        WIRED = 4
+        NONE = 255
+
+    class RfSignal(Enum):
+        """Wireless zone sensor RF signal level (V2 ``RfSignal``)."""
+
+        FULL = 0
+        HALF = 1
+        QUARTER = 2
+        NONE = 3
+
+    class BatteryLevel(Enum):
+        """Wireless zone sensor battery level (V2 ``BattVolt``)."""
+
+        FULL = 0
+        HALF = 1
+        EMPTY = 2
+
     DictValue = str | int | float
     ZoneData = dict[str, DictValue]
 
@@ -117,6 +143,51 @@ class Zone:
         """Minimum allowed airflow for the zone as a percent."""
         return cast(int, self._get_zone_state("MinAir"))
 
+    @property
+    def damper_position(self) -> int | None:
+        """Current damper position as a percent, or ``None`` if not reported.
+
+        V2 only. Bridges without damper position feedback report a constant 50.
+        """
+        return self._int_state("DmpPos")
+
+    @property
+    def damper_fault(self) -> bool | None:
+        """True if the zone damper motor reports a fault, or ``None`` if not reported."""
+        return self._bool_state("DmpFlt")
+
+    @property
+    def sensor_fault(self) -> bool | None:
+        """True if the zone sensor reports a fault, or ``None`` if not reported.
+
+        V2 only.
+        """
+        return self._bool_state("SensorFault")
+
+    @property
+    def rf_signal(self) -> Zone.RfSignal | None:
+        """Wireless sensor RF signal level, or ``None`` if not reported.
+
+        V2 only. Only meaningful for wireless :attr:`sensor_type` zones.
+        """
+        return self._enum_state(Zone.RfSignal, "RfSignal")
+
+    @property
+    def battery_level(self) -> Zone.BatteryLevel | None:
+        """Wireless sensor battery level, or ``None`` if not reported.
+
+        V2 only. Only meaningful for wireless :attr:`sensor_type` zones.
+        """
+        return self._enum_state(Zone.BatteryLevel, "BattVolt")
+
+    @property
+    def sensor_type(self) -> Zone.SensorType | None:
+        """Zone temperature sensor type, or ``None`` if not reported.
+
+        V2 only.
+        """
+        return self._enum_state(Zone.SensorType, "SensType")
+
     async def set_airflow_min(self, value: int) -> None:
         """Change the zone minimum airflow in 5% increments.
 
@@ -224,6 +295,28 @@ class Zone:
     def _get_zone_state(self, state: str) -> DictValue:
         return self._zone_data[state]
 
+    def _int_state(self, state: str) -> int | None:
+        value = self._zone_data.get(state)
+        if isinstance(value, bool) or not isinstance(value, int):
+            return None
+        return value
+
+    def _bool_state(self, state: str) -> bool | None:
+        # V1 sends "true"/"false"; V2 sends 0/1.
+        match self._zone_data.get(state):
+            case "true" | 1:
+                return True
+            case "false" | 0:
+                return False
+            case _:
+                return None
+
+    def _enum_state[E: Enum](self, enum: builtins.type[E], state: str) -> E | None:
+        try:
+            return enum(self._zone_data[state])
+        except KeyError, ValueError:
+            return None
+
     async def _send_command(self, command: str, data: str | float) -> None:
         """Send a zone command via the parent controller.
 

{python_izone-1.3.11 → python_izone-1.3.12}/tests/test_control_zone.py

@@ -31,6 +31,7 @@ async def test_zones_mode_uses_ctrlzone_despite_const_temp_zero(
     [
         pytest.param("RAS", 1, False, "self", 23.5, id="ras"),
         pytest.param("master", 13, False, "self", 23.5, id="master_unit"),
+        pytest.param("zones", 15, False, "self", 23.5, id="unit_sentinel"),
         pytest.param("master", 1, False, 1, 23.5, id="master_zone"),
         pytest.param("zones", 1, True, "self", 23.5, id="auto_missing_cts"),
         pytest.param("zones", 99, False, None, None, id="unmatched_zone"),
@@ -64,3 +65,25 @@ async def test_control_zone_ownership(
         assert controller.control_setpoint is None
     else:
         assert controller.control_setpoint == pytest.approx(setpoint)
+
+
+@pytest.mark.parametrize(
+    ("ras_mode", "owns"),
+    [
+        pytest.param("RAS", True, id="ras"),
+        pytest.param("master", False, id="master"),
+        pytest.param("zones", False, id="zones"),
+    ],
+)
+@pytest.mark.asyncio
+async def test_missing_ctrlzone_has_no_zone_owner(
+    service: MockDiscoveryService, ras_mode: str, owns: bool
+) -> None:
+    """A missing CtrlZone must not fall back to zone 0."""
+    controller = cast(MockController, service._controllers["000000001"])
+    controller._system_settings["RAS"] = ras_mode
+    del controller._system_settings["CtrlZone"]
+
+    assert controller.zone_ctrl is None
+    assert (controller.control_setpoint_owner is controller) is owns
+    assert controller.control_setpoint_owner is not controller.zones[0]

{python_izone-1.3.11 → python_izone-1.3.12}/tests/test_controller.py

@@ -905,7 +905,7 @@ async def test_v2_refresh_sequential_zones_keeps_battery() -> None:
 
     assert controller.is_v2 is True
     assert controller._read_api == "v2"
-    assert controller.zones[0].dump_state()["BattVolt"] == 310
+    assert controller.zones[0].dump_state()["BattVolt"] == 1
 
     controller.sent.clear()
     controller.v2_zones = {
@@ -1084,3 +1084,78 @@ async def test_v2_other_commands_do_not_fall_back_on_command_error() -> None:
         await controller.set_sleep_timer(30)
     assert not any(cmd == "SleepTimer" for cmd, _ in controller.sent)
     await svc.close()
+
+
+# disposition: 1.4
+@pytest.mark.asyncio
+async def test_v1_status_properties(service_14: MockDiscoveryService) -> None:
+    controller = cast(MockController, service_14._controllers["000000001"])
+
+    assert controller.airflow_lock is False
+    assert controller.airflow_min_lock is True
+    assert controller.system_locked is False
+    assert controller.indoor_humidity is None
+    assert controller.indoor_tvoc is None
+    assert controller.indoor_eco2 is None
+
+
+# disposition: 1.4
+@pytest.mark.asyncio
+async def test_v2_status_properties(service_14: MockDiscoveryService) -> None:
+    controller = cast(MockController, service_14._controllers["000000001"])
+    controller._system_settings = v2_mod.system_v2_to_settings(
+        SAMPLE_SYSTEM_V2["SystemV2"], "000000001"
+    )
+
+    assert controller.airflow_lock is False
+    assert controller.airflow_min_lock is False
+    assert controller.system_locked is False
+    assert controller.indoor_humidity == 50
+    assert controller.indoor_tvoc == 0
+    assert controller.indoor_eco2 == 400
+
+
+# disposition: 1.4
+@pytest.mark.parametrize(
+    ("cached", "airflow_lock", "airflow_min_lock"),
+    [
+        pytest.param({"AirflowLock": "on"}, True, True, id="on"),
+        pytest.param({"AirflowLock": "onMin"}, False, True, id="on-min"),
+        pytest.param({"AirflowLock": "off"}, False, False, id="off"),
+        pytest.param({"AirflowLock": "weird"}, None, None, id="unknown"),
+        pytest.param({}, None, None, id="absent"),
+    ],
+)
+@pytest.mark.asyncio
+async def test_airflow_lock_decoding(
+    service_14: MockDiscoveryService,
+    cached: dict[str, str],
+    airflow_lock: bool | None,
+    airflow_min_lock: bool | None,
+) -> None:
+    controller = cast(MockController, service_14._controllers["000000001"])
+    controller._system_settings.pop("AirflowLock")
+    controller._system_settings.update(cached)
+
+    assert controller.airflow_lock is airflow_lock
+    assert controller.airflow_min_lock is airflow_min_lock
+
+
+# disposition: 1.4
+@pytest.mark.parametrize(
+    ("cached", "expected"),
+    [
+        pytest.param({"UnitLocked": "true"}, True, id="locked"),
+        pytest.param({"UnitLocked": "false"}, False, id="unlocked"),
+        pytest.param({}, None, id="absent"),
+    ],
+)
+@pytest.mark.asyncio
+async def test_system_locked_decoding(
+    service_14: MockDiscoveryService, cached: dict[str, str], expected: bool | None
+) -> None:
+    controller = cast(MockController, service_14._controllers["000000001"])
+    controller._system_settings.pop("UnitLocked")
+    controller._system_settings.update(cached)
+
+    assert controller.system_locked is expected

{python_izone-1.3.11 → python_izone-1.3.12}/tests/test_discovery_api.py

@@ -960,7 +960,7 @@ async def test_create_controller_prefers_useful_v2() -> None:
     assert controller.mode == Controller.Mode.HEAT
     assert controller.fan == Controller.Fan.LOW
     assert len(controller.zones) == 2
-    assert controller.zones[0].dump_state()["BattVolt"] == 310
+    assert controller.zones[0].dump_state()["BattVolt"] == 1
     assert controller.zones[0].name == "Kitchen"
     # Type=1 system + Type=2 x2 zones (no V1 GET).
     assert session.get_calls == 0

{python_izone-1.3.11 → python_izone-1.3.12}/tests/test_v2.py

@@ -142,17 +142,114 @@ def test_free_air_reads_from_isave_fields(
     assert settings["FreeAir"] == expected
 
 
-def test_zones_v2_to_zone_data_preserves_battery() -> None:
-    zone = v2_mod.zones_v2_to_zone_data(cast(dict, SAMPLE_ZONES_V2[0]["ZonesV2"]))
+def test_zones_v2_to_zone_data_passes_through_v2_keys() -> None:
+    zone_v2 = SAMPLE_ZONES_V2[0]["ZonesV2"]
+    zone = v2_mod.zones_v2_to_zone_data(cast(dict, zone_v2))
     assert zone["Index"] == 0
     assert zone["Name"] == "Kitchen"
     assert zone["Type"] == "auto"
     assert zone["Mode"] == "auto"
     assert zone["SetPoint"] == 22.5
     assert abs(float(zone["Temp"]) - 21.08) < 0.001
-    assert zone["BattVolt"] == 310
-    assert zone["DmpPos"] == 45
-    assert zone["RfSignal"] == 80
+    for key in (
+        "SensType",
+        "DmpFlt",
+        "iSense",
+        "Area",
+        "Calibration",
+        "Bypass",
+        "DmpPos",
+        "RfSignal",
+        "BattVolt",
+        "SensorFault",
+        "BalanceMax",
+        "BalanceMin",
+        "DamperSkip",
+    ):
+        assert zone[key] == zone_v2[key]
+    # Normalized under V1 names, not duplicated raw.
+    assert "ZoneType" not in zone
+    assert "Setpoint" not in zone
+
+
+def test_system_v2_to_settings_passes_through_v2_keys() -> None:
+    settings = v2_mod.system_v2_to_settings(
+        cast(dict, SAMPLE_SYSTEM_V2["SystemV2"]), "000025841"
+    )
+    assert settings["FilterWarn"] == 3
+    assert settings["InRh"] == 50
+    assert settings["IneCO2"] == 400
+    assert settings["UnitOpt.RA"] == 1
+    assert settings["Temperzone.HeatSetpoint"] == 3500
+    assert settings["GasHeat.CycleFanHeat"] == 0
+    assert "UnitOpt" not in settings
+    # V1-shaped values win over raw V2 keys of the same name.
+    assert settings["Setpoint"] == "22.5"
+    assert settings["AirflowLock"] == "off"
+    assert settings["UnitLocked"] == "false"
+    assert "AirflowMinLock" not in settings
+    assert "LockStatus" not in settings
+
+
+def test_system_v2_missing_ctrlzone_stays_missing() -> None:
+    system = {
+        key: value
+        for key, value in SAMPLE_SYSTEM_V2["SystemV2"].items()
+        if key != "CtrlZone"
+    }
+    settings = v2_mod.system_v2_to_settings(cast(dict, system), "000025841")
+    assert "CtrlZone" not in settings
+
+
+def test_system_v2_to_settings_drops_secrets() -> None:
+    settings = v2_mod.system_v2_to_settings(
+        cast(dict, SAMPLE_SYSTEM_V2["SystemV2"]), "000025841"
+    )
+    assert "LockCode" not in settings
+    assert "Pass" not in settings
+    assert "123456" not in settings.values()
+    assert "secret" not in settings.values()
+
+
+@pytest.mark.parametrize(
+    ("airflow_lock", "airflow_min_lock", "expected"),
+    [
+        (0, 0, "off"),
+        (0, 1, "onMin"),
+        (1, 0, "on"),
+        (1, 1, "on"),
+    ],
+)
+def test_system_v2_airflow_lock_translates_to_v1(
+    airflow_lock: int, airflow_min_lock: int, expected: str
+) -> None:
+    system = {
+        **SAMPLE_SYSTEM_V2["SystemV2"],
+        "AirflowLock": airflow_lock,
+        "AirflowMinLock": airflow_min_lock,
+    }
+    settings = v2_mod.system_v2_to_settings(cast(dict, system), "000025841")
+    assert settings["AirflowLock"] == expected
+
+
+@pytest.mark.parametrize(("lock_status", "expected"), [(0, "false"), (1, "true")])
+def test_system_v2_lock_status_translates_to_v1(
+    lock_status: int, expected: str
+) -> None:
+    system = {**SAMPLE_SYSTEM_V2["SystemV2"], "LockStatus": lock_status}
+    settings = v2_mod.system_v2_to_settings(cast(dict, system), "000025841")
+    assert settings["UnitLocked"] == expected
+
+
+def test_system_v2_without_lock_keys_omits_v1_lock_keys() -> None:
+    system = {
+        key: value
+        for key, value in SAMPLE_SYSTEM_V2["SystemV2"].items()
+        if key not in ("AirflowLock", "AirflowMinLock", "LockStatus")
+    }
+    settings = v2_mod.system_v2_to_settings(cast(dict, system), "000025841")
+    assert "AirflowLock" not in settings
+    assert "UnitLocked" not in settings
 
 
 @pytest.mark.asyncio