python-izone 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

pizone/__init__.py

@@ -8,17 +8,24 @@ Synchronous property reads return cached device data and do not raise
 raise :exc:`ConnectionError` when the device cannot be reached. They raise
 :exc:`~pizone.exceptions.ControllerCommandError` when the device responds but
 rejects the request (``{ERROR...}`` body or HTTP 4xx).
+
+Layered connection state on :class:`~pizone.controller.Controller`:
+
+- :attr:`~pizone.controller.Controller.bridge_connected` — ASH bridge HTTP transport
+- :attr:`~pizone.controller.Controller.connected` — bridge plus valid iZone AC data
+- :attr:`~pizone.power.Power.connected` — power monitor I/O (when enabled)
 """
 
 from .controller import Controller
 from .discovery import DiscoveryService, Listener, discovery
-from .exceptions import ControllerCommandError
+from .exceptions import ControllerCommandError, ResponseDecodeError
 from .power import BatteryLevel, Power, PowerChannel, PowerDevice, PowerGroup
 from .zone import Zone
 
 __all__ = [
     "Controller",
     "ControllerCommandError",
+    "ResponseDecodeError",
     "Zone",
     "DiscoveryService",
     "Listener",

pizone/controller.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, Any, cast
 
 import aiohttp
 
-from .exceptions import ControllerCommandError
+from .exceptions import ControllerCommandError, ResponseDecodeError
 from .power import Power
 from .zone import Zone
 
@@ -33,9 +33,10 @@ class Controller:
     They raise :exc:`ConnectionError` when the device cannot be reached.
     They raise :exc:`~pizone.exceptions.ControllerCommandError` when the
     device responds but rejects the request (``{ERROR...}`` body or HTTP 4xx).
-    A successful transport request clears a prior connection failure and
-    notifies listeners via
-    :meth:`~pizone.discovery.Listener.controller_reconnected`.
+
+    :attr:`connected` is ``True`` when the ASH bridge is reachable over HTTP
+    and the iZone AC subsystem last returned valid system data. Check
+    :attr:`bridge_connected` for bridge transport health alone.
     """
 
     class Mode(Enum):
@@ -78,6 +79,27 @@ class Controller:
         "var-speed": [Fan.LOW, Fan.MED, Fan.HIGH, Fan.AUTO],
     }
 
+    _FAULT_STATE_VALUES = frozenset({"error"})
+    _SYSTEM_STATE_DEFAULTS: ControllerData = {
+        "SysOn": "off",
+        "SysMode": "cool",
+        "SysFan": "auto",
+        "SleepTimer": 0,
+        "FreeAir": "disabled",
+        "Supply": "0.0",
+        "Setpoint": "0.0",
+        "Temp": "0.0",
+        "EcoLock": "false",
+        "EcoMin": "15.0",
+        "EcoMax": "30.0",
+        "RAS": "zones",
+        "CtrlZone": 0,
+        "NoOfZones": 0,
+        "NoOfConst": 0,
+        "SysType": "0",
+        "FanAuto": "disabled",
+    }
+
     def __init__(
         self,
         discovery_service: DiscoveryService,
@@ -113,7 +135,8 @@ class Controller:
         self._power: Power | None = None
 
         self._initialized: bool = False
-        self._fail_exception: Exception | None = None
+        self._bridge_ok: bool = True
+        self._izone_ok: bool = True
 
         self._sending_lock = Lock()
         self._scan_condition = Condition()
@@ -125,15 +148,20 @@ class Controller:
             ConnectionError: If a required HTTP request fails.
             KeyError: If a required field is missing from a device response.
         """
-        await self._refresh_system(notify=False)
-
-        self.fan_modes = Controller._VALID_FAN_MODES[
-            str(self._system_settings.get("FanAuto", "disabled"))
-        ]
+        settings = await self._refresh_system(notify=False)
+        if settings is None:
+            raise ConnectionError("SystemSettings device ID mismatch")
+
+        if self._system_settings:
+            self.fan_modes = Controller._VALID_FAN_MODES[
+                str(self._system_settings.get("FanAuto", "disabled"))
+            ]
+        else:
+            self.fan_modes = Controller._VALID_FAN_MODES["disabled"]
 
         await self._probe_v2_api()
 
-        zone_count = int(self._system_settings["NoOfZones"])
+        zone_count = int(settings["NoOfZones"])
         self.zones = [Zone(self, i) for i in range(zone_count)]
 
         await self._refresh_zones(notify=False)
@@ -141,15 +169,18 @@ class Controller:
         await self._probe_power()
 
         self._initialized = True
+        if not self.connected:
+            self._event_coordinator.controller_disconnected(
+                self, ConnectionError("iZone controller unavailable")
+            )
         self._discovery_service.create_task(self._poll_loop())
 
     async def _probe_v2_api(self) -> None:
         """Detect V2 API support; non-fatal on failure."""
         try:
-            response = await self._send_command_async(
+            response = await self._http_post(
                 "iZoneRequestV2",
                 {"iZoneV2Request": {"Type": 1, "No": 0, "No1": 0}},
-                mark_disconnected=False,
             )
             data = json.loads(response)
             uid = data["AirStreamDeviceUId"]
@@ -165,7 +196,7 @@ class Controller:
 
         try:
             power = Power(self)
-            await power.init(mark_disconnected=False)
+            await power.init()
             if power.enabled:
                 self._power = power
                 return
@@ -215,10 +246,15 @@ class Controller:
         async with self._scan_condition:
             self._scan_condition.notify()
 
+    @property
+    def bridge_connected(self) -> bool:
+        """True while the ASH bridge is reachable over HTTP."""
+        return self._bridge_ok
+
     @property
     def connected(self) -> bool:
-        """True while the controller can reach the device over HTTP."""
-        return self._fail_exception is None
+        """True while the bridge is up and the iZone AC subsystem is available."""
+        return self._bridge_ok and self._izone_ok
 
     @property
     def power(self) -> Power | None:
@@ -265,14 +301,13 @@ class Controller:
 
     @property
     def mode(self) -> Mode:
-        """System mode (cooling, heating, etc.).
-
-        Raises:
-            ValueError: If the cached mode is not a valid :class:`Mode` member.
-        """
+        """System mode (cooling, heating, etc.)."""
         if self.free_air:
             return self.Mode.FREE_AIR
-        return self.Mode(self._get_system_state("SysMode"))
+        try:
+            return self.Mode(self._get_system_state("SysMode"))
+        except ValueError:
+            return self.Mode.COOL
 
     async def set_mode(self, value: Mode) -> None:
         """Set the system mode (cooling, heating, etc.).
@@ -294,12 +329,11 @@ class Controller:
 
     @property
     def fan(self) -> Fan:
-        """The current fan level.
-
-        Raises:
-            ValueError: If the cached fan mode is not a valid :class:`Fan` member.
-        """
-        return self.Fan(self._get_system_state("SysFan"))
+        """The current fan level."""
+        try:
+            return self.Fan(self._get_system_state("SysFan"))
+        except ValueError:
+            return self.Fan.AUTO
 
     async def set_fan(self, value: Fan) -> None:
         """Set the fan level.
@@ -476,19 +510,25 @@ class Controller:
             ConnectionError: If any HTTP request fails.
             KeyError: If a required field is missing from a device response.
         """
-        zones = int(self._system_settings["NoOfZones"])
-        # gather schedules all refresh coroutines together; _sending_lock serializes
-        # HTTP to one in-flight request per controller. Revisit the lock if firmware
-        # supports concurrent requests — gather can stay.
+        zones = len(self.zones)
+        if zones == 0:
+            await asyncio.gather(
+                self._refresh_system(notify),
+                self._refresh_power(notify),
+            )
+            return
         await asyncio.gather(
             self._refresh_system(notify),
             self._refresh_power(notify),
             *[self._refresh_zone_group(i, notify) for i in range(0, zones, 4)],
         )
 
-    async def _refresh_system(self, notify: bool = True) -> None:
+    async def _refresh_system(self, notify: bool = True) -> ControllerData | None:
         """Refresh the system settings from the device.
 
+        Returns the device response even when the payload is a fault placeholder,
+        so callers can read fields like ``NoOfZones`` during initialization.
+
         Raises:
             ConnectionError: If the HTTP request fails.
             KeyError: If the response is missing required fields.
@@ -496,25 +536,40 @@ class Controller:
         values: Controller.ControllerData = await self._get_resource("SystemSettings")
         if self._device_uid != values["AirStreamDeviceUId"]:
             _LOG.error("_refresh_system called with non-matching device ID")
-            return
+            return None
 
-        self._system_settings = values
+        if not self._system_settings_valid(values):
+            _LOG.warning(
+                "iZone subsystem fault uid=%s; retaining cache",
+                self._device_uid,
+            )
+            self._set_izone_ok(
+                False, ConnectionError("iZone controller unavailable")
+            )
+            if notify:
+                self._event_coordinator.controller_update(self)
+            return values
 
+        self._system_settings = values
+        self._set_izone_ok(True)
         if notify:
             self._event_coordinator.controller_update(self)
+        return values
 
     async def _refresh_power(self, notify: bool = True) -> None:
-        """Refresh power monitor data when enabled.
-
-        Raises:
-            ConnectionError: If the HTTP request fails.
-            json.JSONDecodeError: If the device response is not valid JSON.
-            KeyError: If the response is missing required fields.
-        """
+        """Refresh power monitor data when enabled."""
         if self._power is None or not self._power.enabled:
             return
 
-        updated = await self._power.refresh()
+        try:
+            updated = await self._power.refresh()
+        except (ConnectionError, ControllerCommandError, json.JSONDecodeError, KeyError):
+            _LOG.warning(
+                "Power refresh failed for uid=%s",
+                self._device_uid,
+                exc_info=True,
+            )
+            return
 
         if updated and notify:
             self._event_coordinator.power_update(self)
@@ -527,7 +582,9 @@ class Controller:
             KeyError: If a response is missing required fields.
             AttributeError: If a zone index in the response does not match.
         """
-        zones = int(self._system_settings["NoOfZones"])
+        zones = len(self.zones)
+        if zones == 0:
+            return
         await asyncio.gather(
             *[self._refresh_zone_group(i, notify) for i in range(0, zones, 4)]
         )
@@ -555,12 +612,26 @@ class Controller:
     def _refresh_address(self, address: str) -> None:
         """Update the device IP and schedule a reconnect attempt if needed."""
         self._ip = address
-        # Signal to the retry connection loop to have another go.
-        if self._fail_exception:
+        if not self._bridge_ok:
             self._discovery_service.create_task(self._retry_connection())
 
+    @staticmethod
+    def _system_settings_valid(values: ControllerData) -> bool:
+        """Return whether *values* look like healthy AC subsystem data."""
+        return (
+            int(values["NoOfZones"]) > 0
+            and str(values["SysFan"]) != "error"
+            and str(values["RAS"]) != "error"
+        )
+
     def _get_system_state(self, state: str) -> DictValue:
-        return self._system_settings[state]
+        default = self._SYSTEM_STATE_DEFAULTS.get(state, "")
+        value = self._system_settings.get(state)
+        if value is None:
+            return default
+        if state in ("SysFan", "RAS", "SysMode") and str(value) in self._FAULT_STATE_VALUES:
+            return default
+        return value
 
     async def _set_system_state(
         self,
@@ -583,33 +654,47 @@ class Controller:
         self._event_coordinator.controller_update(self)
         await self.refresh()
 
-    def _failed_connection(self, ex: Exception) -> None:
-        if self._fail_exception:
-            self._fail_exception = ex
-            return
-        self._fail_exception = ex
-        if not self._initialized:
+    def _set_bridge_ok(self, ok: bool, ex: Exception | None = None) -> None:
+        was_connected = self.connected
+        self._bridge_ok = ok
+        if not ok and ex is None:
+            ex = ConnectionError("Unable to connect to the controller")
+        self._notify_connected_changed(was_connected, ex if not ok else None)
+
+    def _set_izone_ok(self, ok: bool, ex: Exception | None = None) -> None:
+        was_connected = self.connected
+        self._izone_ok = ok
+        if not ok and ex is None:
+            ex = ConnectionError("iZone controller unavailable")
+        self._notify_connected_changed(was_connected, ex if not ok else None)
+
+    def _notify_connected_changed(
+        self, was_connected: bool, ex: Exception | None
+    ) -> None:
+        if was_connected == self.connected or not self._initialized:
             return
-        self._event_coordinator.controller_disconnected(self, ex)
+        if self.connected:
+            self._event_coordinator.controller_update(self)
+            for zone in self.zones:
+                self._event_coordinator.zone_update(self, zone)
+            self._event_coordinator.power_update(self)
+            self._event_coordinator.controller_reconnected(self)
+        elif ex is not None:
+            self._event_coordinator.controller_disconnected(self, ex)
+
+    def _failed_connection(self, ex: Exception) -> None:
+        """Mark the bridge transport as failed."""
+        self._set_bridge_ok(False, ex)
 
     def _restored_connection(self) -> None:
-        """Clear a prior connection failure after successful I/O."""
-        if self._fail_exception is None:
-            return
-        self._fail_exception = None
-        if not self._initialized:
-            return
-        self._event_coordinator.controller_update(self)
-        for zone in self.zones:
-            self._event_coordinator.zone_update(self, zone)
-        self._event_coordinator.power_update(self)
-        self._event_coordinator.controller_reconnected(self)
+        """Mark the bridge transport as restored."""
+        self._set_bridge_ok(True)
 
     async def _retry_connection(self) -> None:
         """Attempt to restore connectivity after a connection failure.
 
         Connection errors are logged and not re-raised. A successful refresh
-        restores :attr:`connected` via :meth:`_restored_connection`.
+        restores :attr:`connected` when both bridge and iZone layers recover.
         """
         _LOG.info(
             "Attempting to reconnect to server uid=%s ip=%s",
@@ -627,95 +712,124 @@ class Controller:
                 exc_info=True,
             )
 
+    async def _http_get(self, resource: str) -> Any:
+        """Fetch a JSON resource via HTTP GET without updating connection state.
+
+        Raises:
+            ConnectionError: If the device cannot be reached.
+            ResponseDecodeError: If the response cannot be decoded as JSON.
+            ControllerCommandError: If the device returns HTTP 4xx.
+        """
+        session = self._discovery_service.session
+        if session is None:
+            raise ConnectionError("Discovery service is not started")
+        async with (
+            self._sending_lock,
+            session.get(
+                f"http://{self.device_ip}/{resource}",
+                timeout=aiohttp.ClientTimeout(total=Controller.REQUEST_TIMEOUT),
+            ) as response,
+        ):
+            if response.status >= 400 and response.status < 500:
+                raise ControllerCommandError(
+                    f"HTTP {response.status} for http://{self.device_ip}/{resource}"
+                )
+            try:
+                return await response.json(content_type=None)
+            except json.JSONDecodeError as ex:
+                text = await response.text()
+                if text[-4:] == "{OK}":
+                    return json.loads(text[:-4])
+                _LOG.error('Decode error for "%s"', text, exc_info=True)
+                raise ResponseDecodeError(
+                    "Unable to decode response from the controller"
+                ) from ex
+
+    async def _http_post(self, command: str, data: dict[str, Any]) -> str:
+        """Send a command via HTTP POST without updating connection state.
+
+        Raises:
+            ConnectionError: If the device cannot be reached or the HTTP request fails.
+            ControllerCommandError: If the device returns HTTP 4xx or an
+                ``{ERROR...}`` payload.
+        """
+        session = self._discovery_service.session
+        if session is None:
+            raise ConnectionError("Discovery service is not started")
+        body = json.dumps(data).encode("latin_1")
+        async with (
+            self._sending_lock,
+            session.post(
+                f"http://{self.device_ip}/{command}",
+                data=body,
+                headers={"Connection": "close"},
+                timeout=aiohttp.ClientTimeout(total=Controller.REQUEST_TIMEOUT),
+            ) as response,
+        ):
+            if response.status >= 400 and response.status < 500:
+                raise ControllerCommandError(
+                    f"HTTP {response.status} for http://{self.device_ip}/{command}"
+                )
+            if response.status != 200:
+                raise ConnectionError(
+                    f"Unable to connect to: http://{self.device_ip}/{command}"
+                    f" response={response.status} message={response.reason}"
+                )
+            result = await response.text(encoding="latin_1")
+
+        if len(result) >= 7 and result[:6] == "{ERROR":
+            raise ControllerCommandError(f"Server returned error state {result}")
+        if len(result) >= 4 and result[-4:] == "{OK}":
+            result = result[:-4]
+        return result
+
     async def _get_resource(self, resource: str) -> Any:
         """Fetch a JSON resource from the device via HTTP GET.
 
         Raises:
-            ConnectionError: If the device cannot be reached, the response
-                cannot be decoded, or the HTTP request fails.
+            ConnectionError: If the device cannot be reached or the HTTP request fails.
+            ResponseDecodeError: If the response cannot be decoded as JSON.
             ControllerCommandError: If the device returns HTTP 4xx.
         """
         try:
-            session = self._discovery_service.session
-            if session is None:
-                raise ConnectionError("Discovery service is not started")
-            async with (
-                self._sending_lock,
-                session.get(
-                    f"http://{self.device_ip}/{resource}",
-                    timeout=aiohttp.ClientTimeout(total=Controller.REQUEST_TIMEOUT),
-                ) as response,
-            ):
-                if response.status >= 400 and response.status < 500:
-                    self._restored_connection()
-                    raise ControllerCommandError(
-                        f"HTTP {response.status} for http://{self.device_ip}/{resource}"
-                    )
-                try:
-                    result = await response.json(content_type=None)
-                except json.JSONDecodeError as ex:
-                    text = await response.text()
-                    if text[-4:] == "{OK}":
-                        result = json.loads(text[:-4])
-                    else:
-                        _LOG.error('Decode error for "%s"', text, exc_info=True)
-                        raise ConnectionError(
-                            "Unable to decode response from the controller"
-                        ) from ex
-                self._restored_connection()
-                return result
+            result = await self._http_get(resource)
+        except ControllerCommandError:
+            self._set_bridge_ok(True)
+            raise
         except (asyncio.TimeoutError, aiohttp.ClientError) as ex:
-            self._failed_connection(ex)
+            self._set_bridge_ok(
+                False, ConnectionError("Unable to connect to the controller")
+            )
             raise ConnectionError("Unable to connect to the controller") from ex
+        except ResponseDecodeError:
+            self._set_bridge_ok(True)
+            raise
+        except ConnectionError as ex:
+            self._set_bridge_ok(False, ex)
+            raise
+        self._set_bridge_ok(True)
+        return result
 
-    async def _send_command_async(
-        self, command: str, data: dict[str, Any], *, mark_disconnected: bool = True
-    ) -> str:
+    async def _send_command_async(self, command: str, data: dict[str, Any]) -> str:
         """Send a command to the device via HTTP POST.
 
-        Args:
-            mark_disconnected: When ``False``, transport failures do not mark
-                the controller disconnected.
-
         Raises:
             ConnectionError: If the device cannot be reached or the HTTP request fails.
             ControllerCommandError: If the device returns HTTP 4xx or an
                 ``{ERROR...}`` payload.
         """
         try:
-            session = self._discovery_service.session
-            if session is None:
-                raise ConnectionError("Discovery service is not started")
-            body = json.dumps(data).encode("latin_1")
-            async with (
-                self._sending_lock,
-                session.post(
-                    f"http://{self.device_ip}/{command}",
-                    data=body,
-                    headers={"Connection": "close"},
-                    timeout=aiohttp.ClientTimeout(total=Controller.REQUEST_TIMEOUT),
-                ) as response,
-            ):
-                if response.status >= 400 and response.status < 500:
-                    self._restored_connection()
-                    raise ControllerCommandError(
-                        f"HTTP {response.status} for http://{self.device_ip}/{command}"
-                    )
-                if response.status != 200:
-                    raise aiohttp.ClientError(
-                        f"Unable to connect to: http://{self.device_ip}/{command}"
-                        f" response={response.status} message={response.reason}"
-                    )
-                result = await response.text(encoding="latin_1")
+            result = await self._http_post(command, data)
+        except ControllerCommandError:
+            self._set_bridge_ok(True)
+            raise
         except (asyncio.TimeoutError, aiohttp.ClientError) as ex:
-            if mark_disconnected:
-                self._failed_connection(ex)
+            self._set_bridge_ok(
+                False, ConnectionError("Unable to connect to controller")
+            )
             raise ConnectionError("Unable to connect to controller") from ex
-
-        if len(result) >= 7 and result[:6] == "{ERROR":
-            self._restored_connection()
-            raise ControllerCommandError(f"Server returned error state {result}")
-        if len(result) >= 4 and result[-4:] == "{OK}":
-            result = result[:-4]
-        self._restored_connection()
+        except ConnectionError as ex:
+            self._set_bridge_ok(False, ex)
+            raise
+        self._set_bridge_ok(True)
         return result

pizone/discovery.py

@@ -415,7 +415,7 @@ class DiscoveryService:
                 return ctrl
         return None
 
-    async def _wrap_update(self, coro: Awaitable[None]) -> None:
+    async def _wrap_update(self, coro: Awaitable[object]) -> None:
         """Run a controller refresh coroutine and log connection failures."""
         try:
             await coro

pizone/exceptions.py

@@ -8,3 +8,11 @@ class ControllerCommandError(Exception):
     device is reachable. Not used for transport failures (timeouts, connection
     refused, etc.) — those remain :exc:`ConnectionError`.
     """
+
+
+class ResponseDecodeError(ConnectionError):
+    """The bridge responded over HTTP but the body could not be decoded as JSON.
+
+    Raised when transport succeeds and the response is not a transport failure,
+    but JSON parsing fails (and the ``{OK}`` suffix workaround does not apply).
+    """

pizone/power.py

@@ -12,6 +12,8 @@ from enum import IntEnum, unique
 from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any, cast
 
+from .exceptions import ControllerCommandError
+
 if TYPE_CHECKING:
     from .controller import Controller
 
@@ -190,22 +192,17 @@ class Power:
         self._status: dict[str, Any] = {"LastReadingNo": -1}
         self._devices = tuple(PowerDevice(self, i) for i in range(5))
         self._groups: tuple[PowerGroup, ...] | None = None
+        self._power_ok: bool = True
 
-    async def init(self, *, mark_disconnected: bool = True) -> None:
+    async def init(self) -> None:
         """Load power monitor configuration from the device.
 
-        Args:
-            mark_disconnected: When ``False``, connection failures during this
-                request do not mark the controller disconnected.
-
         Raises:
             ConnectionError: If the HTTP request fails.
             json.JSONDecodeError: If the device response is not valid JSON.
             KeyError: If the response is missing required fields.
         """
-        self._config = await self._do_request(
-            1, "PowerMonitorConfig", mark_disconnected=mark_disconnected
-        )
+        self._config = await self._do_request(1, "PowerMonitorConfig")
         gdict: dict[int, list[PowerChannel]] = {}
         for dev in self.devices:
             for chan in dev.channels:
@@ -232,28 +229,53 @@ class Power:
         self._status = status
         return True
 
-    async def _do_request(
-        self, req_type: int, result: str, *, mark_disconnected: bool = True
-    ) -> dict[str, Any]:
+    async def _do_request(self, req_type: int, result: str) -> dict[str, Any]:
         """Send a power monitor request to the device.
 
-        Args:
-            mark_disconnected: When ``False``, connection failures do not mark
-                the controller disconnected.
-
         Raises:
             ConnectionError: If the HTTP request fails.
             json.JSONDecodeError: If the device response is not valid JSON.
             KeyError: If the response is missing *result*.
         """
+        if not self._controller.bridge_connected:
+            self._set_power_ok(False)
+            raise ConnectionError("Bridge not connected")
+        try:
+            # pylint: disable=protected-access
+            datas = await self._controller._http_post(
+                "PowerRequest",
+                {"PowerRequest": {"Type": req_type, "No": 0, "No1": 0}},
+            )
+            data = json.loads(datas)
+            payload = cast(dict[str, Any], data[result])
+        except (
+            ConnectionError,
+            ControllerCommandError,
+            json.JSONDecodeError,
+            KeyError,
+        ) as ex:
+            self._set_power_ok(False)
+            if isinstance(ex, ConnectionError):
+                raise
+            if isinstance(ex, json.JSONDecodeError):
+                raise ConnectionError("Invalid power monitor response") from ex
+            if isinstance(ex, KeyError):
+                raise ConnectionError("Invalid power monitor response") from ex
+            raise ConnectionError("Power monitor request failed") from ex
+        self._set_power_ok(True)
+        return payload
+
+    def _set_power_ok(self, ok: bool) -> None:
+        if self._power_ok == ok:
+            return
+        self._power_ok = ok
         # pylint: disable=protected-access
-        datas = await self._controller._send_command_async(
-            "PowerRequest",
-            {"PowerRequest": {"Type": req_type, "No": 0, "No1": 0}},
-            mark_disconnected=mark_disconnected,
-        )
-        data = json.loads(datas)
-        return cast(dict[str, Any], data[result])
+        self._controller._event_coordinator.power_update(self._controller)
+
+    @property
+    def connected(self) -> bool:
+        """True while the bridge is up and power monitor I/O is healthy."""
+        return self._controller.bridge_connected and self._power_ok
 
     @property
     def enabled(self) -> bool:

pizone/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.3.2'
-__version_tuple__ = version_tuple = (1, 3, 2)
+__version__ = version = '1.3.4'
+__version_tuple__ = version_tuple = (1, 3, 4)
 
 __commit_id__ = commit_id = None

pizone/zone.py

@@ -187,6 +187,8 @@ class Zone:
         """
         if zone_data["Index"] != self._index:
             raise AttributeError("Can't change index of existing zone.")
+        if str(zone_data.get("Type")) == "error":
+            return
         self._zone_data = zone_data
         if notify:
             self._fire_listeners()

{python_izone-1.3.2.dist-info → python_izone-1.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-izone
-Version: 1.3.2
+Version: 1.3.4
 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.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+pizone/__init__.py,sha256=F1D0SKGns5TUvAH4iZOovrE4ZQH3GXHWW3bUPcovDrw,1365
+pizone/controller.py,sha256=K0cscWcwHe4OFaVI_F-wV9J-Da3QGNfCFDpKgdVFkCM,30012
+pizone/discovery.py,sha256=8sBl1QlMlkGs_gwt-neGouwpYahwrlkAH37KEw9SbH0,18135
+pizone/exceptions.py,sha256=8rqSGIrQV5KQeOx_Lc6Mh7FVAbSl4-Q6qyW-cwrqlZ0,658
+pizone/power.py,sha256=FsKS8LhyHS2cUDKnDX6Vc1bWhpXSZABIpPLNQERqlLk,9899
+pizone/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pizone/version.py,sha256=J1PLKOPRRvOkHG-jR78Tmen2I1NkbGLw4y0NdfCA_Ts,520
+pizone/zone.py,sha256=0rVYIiqGXUJeT3i_EBLPOTEsFIY6nNSheMuI7Up8GzU,7232
+python_izone-1.3.4.dist-info/METADATA,sha256=mOBTQOsYuJe2T_NaTDB_G-CrBofSrGJoqs9-3qyKFOI,2657
+python_izone-1.3.4.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+python_izone-1.3.4.dist-info/licenses/licence.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_izone-1.3.4.dist-info/RECORD,,

python_izone-1.3.2.dist-info/RECORD

@@ -1,12 +0,0 @@
-pizone/__init__.py,sha256=xRQgtXzCtsGhJDBOzDxV105Trv2NCFe8Em6fZEqZ4bc,997
-pizone/controller.py,sha256=hO2B7sIZt8Djt_Nq0_ov7ocNxBy9Nk_DtkcEmixFt2s,26114
-pizone/discovery.py,sha256=tvZs5npvL2y41vyYxn5V6EDCI9v27_Z-vy_ezSN-RA4,18133
-pizone/exceptions.py,sha256=mWsvXzBNh6mKOPs0QFLqgO6ipa6Se6PEGhFTwr9_ehA,362
-pizone/power.py,sha256=4kWS_XilZki7dLzlJ0cKYoz8s6pS76bAtrHhUXTZ_eg,9039
-pizone/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pizone/version.py,sha256=3UteJz_pk76FGRZGb0537LBHxRlaYKkTw4QYKVpfrjs,520
-pizone/zone.py,sha256=rDv-Q9k9HGIzK3arBxpKoAa-xRGETQkgBOTulMdOhqc,7163
-python_izone-1.3.2.dist-info/METADATA,sha256=pEMLJ6CTDnghdy4FJ8wIducmpD-ZxAnVPv26t347FuQ,2657
-python_izone-1.3.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-python_izone-1.3.2.dist-info/licenses/licence.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-python_izone-1.3.2.dist-info/RECORD,,