python-izone 1.3.2__tar.gz → 1.3.3__tar.gz

{python_izone-1.3.2 → python_izone-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-izone
-Version: 1.3.2
+Version: 1.3.3
 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.2 → python_izone-1.3.3}/pizone/controller.py

@@ -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):
@@ -113,7 +114,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 +127,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 +148,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 +175,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 +225,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:
@@ -476,19 +491,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 +517,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 +563,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,10 +593,18 @@ 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]
 
@@ -583,33 +629,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,6 +687,77 @@ 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 or the response
+                cannot be decoded.
+            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 ConnectionError(
+                    "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.
 
@@ -636,86 +767,44 @@ class Controller:
             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 ConnectionError as ex:
+            if str(ex) == "Unable to decode response from the controller":
+                self._set_bridge_ok(True)
+            else:
+                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

{python_izone-1.3.2 → python_izone-1.3.3}/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

{python_izone-1.3.2 → python_izone-1.3.3}/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:

{python_izone-1.3.2 → python_izone-1.3.3}/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.3'
+__version_tuple__ = version_tuple = (1, 3, 3)
 
 __commit_id__ = commit_id = None

{python_izone-1.3.2 → python_izone-1.3.3}/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 → python_izone-1.3.3}/tests/conftest.py

@@ -62,48 +62,35 @@ class MockController(Controller):
             self._failed_connection(ex)
             raise ConnectionError("Explicitly Disconnected") from ex
 
-    async def _get_resource(self, resource: str) -> Any:
-        """Mock out the network IO for _get_resource."""
+    async def _http_get(self, resource: str) -> Any:
+        """Mock out the network IO for tracked GET requests."""
         self._check_discovery_connected()
         result = self.resources.get(resource)
         if result:
-            self._restored_connection()
             return deepcopy(result)
         raise ConnectionError(f"Mock resource '{resource}' not available")
 
-    async def _send_command_async(
-        self, command: str, data: dict[str, Any], *, mark_disconnected: bool = True
-    ) -> str:
-        """Mock out the network IO for _send_command."""
-        if self._fail_exception:
-            raise ConnectionError(
-                "Unable to connect to the controller"
-            ) from self._fail_exception
+    async def _http_post(self, command: str, data: dict[str, Any]) -> str:
+        """Mock out the network IO for untracked POST requests."""
+        if not self._bridge_ok:
+            raise ConnectionError("Unable to connect to the controller")
         self._check_discovery_connected()
         self.sent.append((command, data))
         if command == "iZoneRequestV2":
             if self.v2_probe_response is not None:
-                self._restored_connection()
                 return self.v2_probe_response
-            ex = ConnectionError("V2 probe failed")
-            if mark_disconnected:
-                self._failed_connection(ex)
-            raise ConnectionError("Unable to connect to controller") from ex
+            raise ConnectionError("Unable to connect to controller")
         if command == "PowerRequest":
             req_type: int = data["PowerRequest"]["Type"]
             if req_type in self.fail_power_types:
-                ex = TimeoutError("Power request failed")
-                if mark_disconnected:
-                    self._failed_connection(ex)
-                raise ConnectionError("Unable to connect to controller") from ex
+                raise ConnectionError("Unable to connect to controller")
             if req_type == 1:
-                config = self.power_config if self.power_config is not None else POWER_CONFIG
-                self._restored_connection()
+                config = (
+                    self.power_config if self.power_config is not None else POWER_CONFIG
+                )
                 return json.dumps({"PowerMonitorConfig": config})
             if req_type == 2:
-                self._restored_connection()
                 return json.dumps({"PowerMonitorStatus": POWER_STATUS})
-        self._restored_connection()
         return ""
 
 

{python_izone-1.3.2 → python_izone-1.3.3}/tests/test_controller.py

@@ -7,10 +7,35 @@ from typing import cast
 import pytest
 from pytest import raises
 
-from pizone import Controller
+from pizone import Controller, Listener
 
 from .conftest import MockController, MockDiscoveryService, _register_mock_service
 from .power_data import POWER_CONFIG
+from .resources import SYSTEMS
+
+
+class _DisconnectListener(Listener):
+    def __init__(self) -> None:
+        self.disconnected = 0
+        self.reconnected = 0
+        self.last_exception: Exception | None = None
+
+    def controller_disconnected(self, _ctrl: Controller, ex: Exception) -> None:
+        self.disconnected += 1
+        self.last_exception = ex
+
+    def controller_reconnected(self, _ctrl: Controller) -> None:
+        self.reconnected += 1
+
+
+def _fault_system_settings(device_uid: str) -> dict[str, object]:
+    settings = deepcopy(SYSTEMS["000000001"]["SystemSettings"])
+    settings["AirStreamDeviceUId"] = device_uid
+    settings["NoOfZones"] = 0
+    settings["SysFan"] = "error"
+    settings["RAS"] = "error"
+    settings["UnitType"] = "No Unit Type Configured!"
+    return settings
 
 
 @pytest.mark.asyncio
@@ -213,7 +238,7 @@ async def test_initialize_clears_ipower_when_config_disabled() -> None:
 
 
 @pytest.mark.asyncio
-async def test_power_init_probe_timeout_does_not_mark_disconnected() -> None:
+async def test_power_init_probe_failure_leaves_controller_connected() -> None:
     svc = MockDiscoveryService()
     original_create = svc._create_controller
 
@@ -234,22 +259,25 @@ async def test_power_init_probe_timeout_does_not_mark_disconnected() -> None:
         controller = cast(MockController, svc._controllers["000000003"])
 
         assert controller.connected is True
-        assert controller._fail_exception is None
+        assert controller.bridge_connected is True
+        assert controller._bridge_ok is True
+        assert controller._izone_ok is True
     finally:
         await svc.close()
 
 
 @pytest.mark.asyncio
-async def test_power_poll_timeout_marks_disconnected(
+async def test_power_poll_failure_does_not_mark_controller_disconnected(
     ipower_service: MockDiscoveryService,
 ) -> None:
     controller = cast(MockController, ipower_service._controllers["000000003"])
+    assert controller.power is not None
     controller.fail_power_types.add(2)
 
-    with raises(ConnectionError):
-        await controller._refresh_power(notify=False)
+    await controller._refresh_power(notify=False)
 
-    assert controller.connected is False
+    assert controller.connected is True
+    assert controller.power.connected is False
 
 
 @pytest.mark.asyncio
@@ -293,3 +321,120 @@ async def test_v2_probe_clears_is_v2_on_http_error() -> None:
         assert controller.is_v2 is False
     finally:
         await svc.close()
+
+
+@pytest.mark.asyncio
+async def test_bridge_ok_true_when_izone_fault(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+    healthy_fan = controller.fan
+
+    controller.resources["SystemSettings"] = _fault_system_settings("000000001")
+    await controller._refresh_system(notify=False)
+
+    assert controller.bridge_connected is True
+    assert controller.connected is False
+    assert controller.fan == healthy_fan
+
+
+@pytest.mark.asyncio
+async def test_cache_preserved_on_izone_fault(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+    healthy_settings = deepcopy(controller.resources["SystemSettings"])
+
+    controller.resources["SystemSettings"] = _fault_system_settings("000000001")
+    await controller._refresh_system(notify=False)
+
+    assert controller._system_settings == healthy_settings
+
+
+@pytest.mark.asyncio
+async def test_connected_restored_on_izone_recovery(
+    service: MockDiscoveryService,
+) -> None:
+    listener = _DisconnectListener()
+    controller = cast(MockController, service._controllers["000000001"])
+    controller._event_coordinator = listener
+    healthy_settings = deepcopy(controller.resources["SystemSettings"])
+
+    controller.resources["SystemSettings"] = _fault_system_settings("000000001")
+    await controller._refresh_system(notify=True)
+    assert listener.disconnected == 1
+
+    controller.resources["SystemSettings"] = healthy_settings
+    await controller._refresh_system(notify=True)
+    assert controller.connected is True
+    assert listener.reconnected == 1
+
+
+@pytest.mark.asyncio
+async def test_no_listener_flutter_repeated_fault_polls(
+    service: MockDiscoveryService,
+) -> None:
+    listener = _DisconnectListener()
+    controller = cast(MockController, service._controllers["000000001"])
+    controller._event_coordinator = listener
+
+    controller.resources["SystemSettings"] = _fault_system_settings("000000001")
+    await controller._refresh_system(notify=True)
+    await controller._refresh_system(notify=True)
+
+    assert listener.disconnected == 1
+    assert listener.reconnected == 0
+
+
+@pytest.mark.asyncio
+async def test_izone_fault_disconnect_uses_connection_error(
+    service: MockDiscoveryService,
+) -> None:
+    listener = _DisconnectListener()
+    controller = cast(MockController, service._controllers["000000001"])
+    controller._event_coordinator = listener
+
+    controller.resources["SystemSettings"] = _fault_system_settings("000000001")
+    await controller._refresh_system(notify=True)
+
+    assert isinstance(listener.last_exception, ConnectionError)
+
+
+@pytest.mark.asyncio
+async def test_v2_probe_failure_leaves_bridge_ok(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+    controller.v2_probe_response = None
+
+    await controller._probe_v2_api()
+
+    assert controller._bridge_ok is True
+    assert controller.bridge_connected is True
+
+
+@pytest.mark.asyncio
+async def test_init_fault_disconnect_listener() -> None:
+    listener = _DisconnectListener()
+    svc = MockDiscoveryService()
+    controller = MockController(
+        svc,
+        listener,
+        device_uid="000000004",
+        device_ip="10.0.0.4",
+        is_v2=False,
+        is_ipower=False,
+    )
+    controller.resources["SystemSettings"] = _fault_system_settings("000000004")
+
+    await controller._initialize()
+
+    assert controller.connected is False
+    assert listener.disconnected == 1
+    assert controller.zones == []
+
+
+@pytest.mark.asyncio
+async def test_both_false_on_transport_failure(service: MockDiscoveryService) -> None:
+    controller = cast(MockController, service._controllers["000000001"])
+    controller._connected = False
+
+    with raises(ConnectionError):
+        await controller._get_resource("SystemSettings")
+
+    assert controller.bridge_connected is False
+    assert controller.connected is False

{python_izone-1.3.2 → python_izone-1.3.3}/tests/test_power.py

@@ -7,21 +7,39 @@ from typing import Any, cast
 import pytest
 
 from pizone import BatteryLevel, Controller, Power
+from pizone.discovery import Listener
 
 from .power_data import POWER_CONFIG, POWER_STATUS
 
 
+class _PowerListener(Listener):
+    def __init__(self) -> None:
+        self.power_updates = 0
+
+    def power_update(self, _controller: Controller) -> None:
+        self.power_updates += 1
+
+
 class MockPowerController:
     """Minimal controller stub for Power unit tests."""
 
-    def __init__(self, responses: dict[int, dict[str, object]]) -> None:
+    def __init__(
+        self,
+        responses: dict[int, dict[str, object]],
+        *,
+        bridge_connected: bool = True,
+        listener: _PowerListener | None = None,
+    ) -> None:
         self._responses = responses
         self.sent: list[tuple[str, dict[str, Any]]] = []
+        self._bridge_ok = bridge_connected
+        self._event_coordinator = listener or _PowerListener()
+
+    @property
+    def bridge_connected(self) -> bool:
+        return self._bridge_ok
 
-    async def _send_command_async(
-        self, command: str, data: dict[str, Any], *, mark_disconnected: bool = True
-    ) -> str:
-        del mark_disconnected
+    async def _http_post(self, command: str, data: dict[str, Any]) -> str:
         self.sent.append((command, data))
         req_type: int = data["PowerRequest"]["Type"]
         return json.dumps(self._responses[req_type])
@@ -39,6 +57,7 @@ async def test_power_init_and_status_last_reading() -> None:
 
     await power.init()
     assert power.enabled is True
+    assert power.connected is True
     assert power.voltage == 240
     assert power.groups is not None
     assert len(power.groups) == 1
@@ -105,3 +124,44 @@ async def test_power_nested_property_reads() -> None:
     assert group.name == "Grid"
     assert group.status_ok is False
     assert group.status_power == 1500
+
+
+@pytest.mark.asyncio
+async def test_power_connected_false_when_bridge_down() -> None:
+    controller = MockPowerController(
+        {1: {"PowerMonitorConfig": POWER_CONFIG}},
+        bridge_connected=False,
+    )
+    power = Power(cast(Controller, controller))
+
+    with pytest.raises(ConnectionError, match="Bridge not connected"):
+        await power.init()
+
+    assert power.connected is False
+
+
+@pytest.mark.asyncio
+async def test_power_connected_restored_on_recovery() -> None:
+    listener = _PowerListener()
+    controller = MockPowerController(
+        {
+            1: {"PowerMonitorConfig": POWER_CONFIG},
+            2: {"PowerMonitorStatus": POWER_STATUS},
+        },
+        listener=listener,
+    )
+    power = Power(cast(Controller, controller))
+    await power.init()
+
+    controller._bridge_ok = False
+    controller._responses = {}
+    with pytest.raises(ConnectionError):
+        await power.refresh()
+    assert power.connected is False
+    assert listener.power_updates == 1
+
+    controller._bridge_ok = True
+    controller._responses = {2: {"PowerMonitorStatus": POWER_STATUS}}
+    await power.refresh()
+    assert power.connected is True
+    assert listener.power_updates == 2