python-izone 1.2.9__py3-none-any.whl → 1.2.10__py3-none-any.whl

pizone/__init__.py

@@ -3,20 +3,20 @@
 Interaction mostly through the Controller and Zone classes.
 """
 
-from .power import Power, PowerGroup, PowerDevice, PowerChannel, BatteryLevel
-from .zone import Zone
 from .controller import Controller
 from .discovery import DiscoveryService, Listener, discovery
+from .power import BatteryLevel, Power, PowerChannel, PowerDevice, PowerGroup
+from .zone import Zone
 
-__ALL__ = [
-    Controller,
-    Zone,
-    DiscoveryService,
-    Listener,
-    discovery,
-    Power,
-    PowerGroup,
-    PowerDevice,
-    PowerChannel,
-    BatteryLevel,
+__all__ = [
+    "Controller",
+    "Zone",
+    "DiscoveryService",
+    "Listener",
+    "discovery",
+    "Power",
+    "PowerGroup",
+    "PowerDevice",
+    "PowerChannel",
+    "BatteryLevel",
 ]

pizone/controller.py

@@ -1,19 +1,23 @@
 """Controller module"""
 
+from __future__ import annotations
+
 import asyncio
 import json
 import logging
 from asyncio import Condition, Lock
 from enum import Enum
 from json.decoder import JSONDecodeError
-from typing import Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Dict, Union, cast
 
 import aiohttp
-from async_timeout import timeout
 
 from .power import Power
 from .zone import Zone
 
+if TYPE_CHECKING:
+    from .discovery import DiscoveryService, Listener
+
 _LOG = logging.getLogger("pizone.controller")
 
 
@@ -58,10 +62,17 @@ class Controller:
         "3-speed": [Fan.LOW, Fan.MED, Fan.HIGH, Fan.AUTO],
         "2-speed": [Fan.LOW, Fan.HIGH, Fan.AUTO],
         "var-speed": [Fan.LOW, Fan.MED, Fan.HIGH, Fan.AUTO],
-    }  # type: Dict[str, List[Fan]]
+    }
 
     def __init__(
-        self, discovery, device_uid: str, device_ip: str, is_v2: bool, is_ipower: bool
+        self,
+        discovery_service: DiscoveryService,
+        event_coordinator: Listener,
+        *,
+        device_uid: str,
+        device_ip: str,
+        is_v2: bool,
+        is_ipower: bool,
     ) -> None:
         """Create a controller interface.
 
@@ -83,25 +94,26 @@ class Controller:
                 device discovered at the given IP address or UId
         """
         self._ip = device_ip
-        self._discovery = discovery
+        self._discovery_service = discovery_service
+        self._event_coordinator = event_coordinator
         self._device_uid = device_uid
         self._is_v2 = is_v2
         self._is_ipower = is_ipower
 
-        self.zones = []  # type: List[Zone]
-        self.fan_modes = []  # type: List[Controller.Fan]
-        self._system_settings = {}  # type: Controller.ControllerData
-        self._power = None  # type: Optional[Power]
+        self.zones: list[Zone] = []
+        self.fan_modes: list[Controller.Fan] = []
+        self._system_settings: Controller.ControllerData = {}
+        self._power: Power | None = None
 
-        self._initialised = False
-        self._fail_exception = None
+        self._initialized: bool = False
+        self._fail_exception: Exception | None = None
 
         self._sending_lock = Lock()
         self._scan_condition = Condition()
 
     async def _initialize(self) -> None:
         """Initialize the controller, does not complete until the system is
-        initialised."""
+        initialized."""
         await self._refresh_system(notify=False)
 
         self.fan_modes = Controller._VALID_FAN_MODES[
@@ -120,13 +132,13 @@ class Controller:
         else:
             self._power = None
 
-        self._initialised = True
-        self._discovery.create_task(self._poll_loop())
+        self._initialized = True
+        self._discovery_service.create_task(self._poll_loop())
 
     async def _poll_loop(self) -> None:
         while True:
             try:
-                async with timeout(Controller.REFRESH_INTERVAL):
+                async with asyncio.timeout(Controller.REFRESH_INTERVAL):
                     async with self._scan_condition:
                         await self._scan_condition.wait()
                 # triggered rescan, short delay
@@ -134,7 +146,7 @@ class Controller:
             except asyncio.TimeoutError:
                 pass
 
-            if self._discovery.is_closed:
+            if self._discovery_service.is_closed:
                 return
 
             # pylint: disable=broad-except
@@ -142,7 +154,7 @@ class Controller:
                 _LOG.debug("Polling unit %s.", self._device_uid)
                 await self._refresh_all()
             except ConnectionError:
-                _LOG.debug("Poll failed due to exeption.", exc_info=True)
+                _LOG.debug("Poll failed due to exception.", exc_info=True)
             except Exception:
                 _LOG.error("Unexpected exception", exc_info=True)
 
@@ -157,7 +169,7 @@ class Controller:
         return self._fail_exception is None
 
     @property
-    def power(self) -> Optional[Power]:
+    def power(self) -> Power | None:
         """Power info"""
         return self._power
 
@@ -177,9 +189,9 @@ class Controller:
         return self._is_v2
 
     @property
-    def discovery(self):
+    def discovery(self) -> Any:
         """The discovery service"""
-        return self._discovery
+        return self._discovery_service
 
     @property
     def is_on(self) -> bool:
@@ -197,7 +209,7 @@ class Controller:
             return self.Mode.FREE_AIR
         return self.Mode(self._get_system_state("SysMode"))
 
-    async def set_mode(self, value: Mode):
+    async def set_mode(self, value: Mode) -> None:
         """Set system mode, cooling, heating, etc."""
         if value == Controller.Mode.FREE_AIR:
             if self.free_air:
@@ -234,7 +246,7 @@ class Controller:
         """Current setting for the sleep timer."""
         return int(self._get_system_state("SleepTimer"))
 
-    async def set_sleep_timer(self, value: int):
+    async def set_sleep_timer(self, value: int) -> None:
         """The sleep timer.
         Valid settings are 0, 30, 60, 90, 120
         Raises:
@@ -268,19 +280,19 @@ class Controller:
         await self._set_system_state("FreeAir", "FreeAir", "on" if value else "off")
 
     @property
-    def temp_supply(self) -> Optional[float]:
+    def temp_supply(self) -> float | None:
         """Current supply, or in duct, air temperature."""
         return float(self._get_system_state("Supply")) or None
 
     @property
-    def temp_setpoint(self) -> Optional[float]:
+    def temp_setpoint(self) -> float | None:
         """AC unit setpoint temperature.
         This is the unit target temp with with rasMode == RAS,
         or with rasMode == master and ctrlZone == 13.
         """
         return float(self._get_system_state("Setpoint")) or None
 
-    async def set_temp_setpoint(self, value: float):
+    async def set_temp_setpoint(self, value: float) -> None:
         """AC unit setpoint temperature.
         This is the unit target temp with with rasMode == RAS,
         or with rasMode == master and ctrlZone == 13.
@@ -298,7 +310,7 @@ class Controller:
         await self._set_system_state("Setpoint", "UnitSetpoint", value, str(value))
 
     @property
-    def temp_return(self) -> Optional[float]:
+    def temp_return(self) -> float | None:
         """The return, or room, air temperature"""
         return float(self._get_system_state("Temp")) or None
 
@@ -314,7 +326,7 @@ class Controller:
 
     @property
     def temp_max(self) -> float:
-        """The value for the eco lock maxium, or 30 if eco lock not set"""
+        """The value for the eco lock maximum, or 30 if eco lock not set"""
         return float(self._get_system_state("EcoMax")) if self.eco_lock else 30.0
 
     @property
@@ -368,17 +380,15 @@ class Controller:
 
     async def _refresh_system(self, notify: bool = True) -> None:
         """Refresh the system settings."""
-        values = await self._get_resource(
-            "SystemSettings"
-        )  # type: Controller.ControllerData  # noqa
+        values: Controller.ControllerData = await self._get_resource("SystemSettings")
         if self._device_uid != values["AirStreamDeviceUId"]:
-            _LOG.error("_refresh_system called with unmatching device ID")
+            _LOG.error("_refresh_system called with non-matching device ID")
             return
 
         self._system_settings = values
 
         if notify:
-            self._discovery.controller_update(self)
+            self._event_coordinator.controller_update(self)
 
     async def _refresh_power(self, notify: bool = True) -> None:
         if self._power is None or not self._power.enabled:
@@ -387,7 +397,7 @@ class Controller:
         updated = await self._power.refresh()
 
         if updated and notify:
-            self._discovery.power_update(self)
+            self._event_coordinator.power_update(self)
 
     async def _refresh_zones(self, notify: bool = True) -> None:
         """Refresh the Zone information."""
@@ -396,7 +406,7 @@ class Controller:
             *[self._refresh_zone_group(i, notify) for i in range(0, zones, 4)]
         )
 
-    async def _refresh_zone_group(self, group: int, notify: bool = True):
+    async def _refresh_zone_group(self, group: int, notify: bool = True) -> None:
         assert group in [0, 4, 8]
         zone_data_part = await self._get_resource(f"Zones{group + 1}_{group + 4}")
 
@@ -405,25 +415,31 @@ class Controller:
             # pylint: disable=protected-access
             self.zones[i + group]._update_zone(zone_data, notify)
 
-    def _refresh_address(self, address):
+    def _refresh_address(self, address: str) -> None:
         """Called from discovery to update the address"""
         self._ip = address
         # Signal to the retry connection loop to have another go.
         if self._fail_exception:
-            self._discovery.create_task(self._retry_connection())
+            self._discovery_service.create_task(self._retry_connection())
 
-    def _get_system_state(self, state):
+    def _get_system_state(self, state: str) -> Any:
         self._ensure_connected()
         return self._system_settings.get(state)
 
-    async def _set_system_state(self, state, command, value, send=None):
+    async def _set_system_state(
+        self,
+        state: str,
+        command: str,
+        value: DictValue,
+        send: Any | None = None,
+    ) -> None:
         if send is None:
             send = value
         await self._send_command_async(command, {command: send})
 
         # Update state and trigger rescan
         self._system_settings[state] = value
-        self._discovery.controller_update(self)
+        self._event_coordinator.controller_update(self)
         await self.refresh()
 
     def _ensure_connected(self) -> None:
@@ -432,14 +448,14 @@ class Controller:
                 "Unable to connect to the controller"
             ) from self._fail_exception
 
-    def _failed_connection(self, ex):
+    def _failed_connection(self, ex: Exception) -> None:
         if self._fail_exception:
             self._fail_exception = ex
             return
         self._fail_exception = ex
-        if not self._initialised:
+        if not self._initialized:
             return
-        self._discovery.controller_disconnected(self, ex)
+        self._event_coordinator.controller_disconnected(self, ex)
 
     async def _retry_connection(self) -> None:
         _LOG.info(
@@ -453,11 +469,11 @@ class Controller:
 
             self._fail_exception = None
 
-            self._discovery.controller_update(self)
+            self._event_coordinator.controller_update(self)
             for zone in self.zones:
-                self._discovery.zone_update(self, zone)
-            self._discovery.power_update(self)
-            self._discovery.controller_reconnected(self)
+                self._event_coordinator.zone_update(self, zone)
+            self._event_coordinator.power_update(self)
+            self._event_coordinator.controller_reconnected(self)
         except ConnectionError:
             # Expected, just carry on.
             _LOG.warning(
@@ -466,13 +482,16 @@ class Controller:
                 exc_info=True,
             )
 
-    async def _get_resource(self, resource: str):
+    async def _get_resource(self, resource: str) -> Any:
         try:
-            session = self._discovery.session
-            async with self._sending_lock, session.get(
-                f"http://{self.device_ip}/{resource}",
-                timeout=Controller.REQUEST_TIMEOUT,
-            ) as response:
+            session = self._discovery_service.session
+            async with (
+                self._sending_lock,
+                session.get(
+                    f"http://{self.device_ip}/{resource}",
+                    timeout=Controller.REQUEST_TIMEOUT,
+                ) as response,
+            ):
                 try:
                     return await response.json(content_type=None)
                 except JSONDecodeError as ex:
@@ -487,9 +506,9 @@ class Controller:
             self._failed_connection(ex)
             raise ConnectionError("Unable to connect to the controller") from ex
 
-    async def _send_command_async(self, command: str, data: Any):
+    async def _send_command_async(self, command: str, data: Any) -> str:
         # For some reason aiohttp fragments post requests, which causes
-        # the server to fail disgracefully. Implimented rough and dirty
+        # the server to fail disgracefully. Implemented rough and dirty
         # HTTP POST client.
         loop = asyncio.get_running_loop()
         on_complete = loop.create_future()
@@ -499,7 +518,7 @@ class Controller:
             def __init__(self) -> None:
                 self.response = bytearray()
 
-            def connection_made(self, transport):
+            def connection_made(self, transport: asyncio.BaseTransport) -> None:
                 body = json.dumps(data).encode("latin_1")
                 header = (
                     f"POST /{command} HTTP/1.1\r\n"
@@ -508,12 +527,12 @@ class Controller:
                     "\r\n"
                 ).encode()
                 _LOG.debug("Writing message to %s", device_ip)
-                transport.write(header + body)
+                cast(asyncio.WriteTransport, transport).write(header + body)
 
-            def data_received(self, data):
+            def data_received(self, data: bytes) -> None:
                 self.response += data
 
-            def eof_received(self):
+            def eof_received(self) -> None:
                 full = self.response.decode("latin_1")
                 if not full:
                     on_complete.set_exception(RuntimeError("Empty HTTP Response"))
@@ -536,7 +555,7 @@ class Controller:
 
         # The server doesn't tolerate multiple requests in fly concurrently
         try:
-            async with self._sending_lock, timeout(Controller.REQUEST_TIMEOUT):
+            async with self._sending_lock, asyncio.timeout(Controller.REQUEST_TIMEOUT):
                 await loop.create_connection(_PostProtocol, self.device_ip, 80)
                 await on_complete
 

pizone/discovery.py

@@ -2,26 +2,23 @@
 
 import asyncio
 import logging
-from abc import ABC, abstractmethod
 from asyncio import (
     CancelledError,
     Condition,
     DatagramProtocol,
     DatagramTransport,
-    Future,
     Task,
 )
-from logging import Logger
-from typing import Dict, List, Optional, Set
+from contextlib import suppress
+from typing import Any
 
-import netifaces # type: ignore
+import netifaces  # type: ignore
 from aiohttp import ClientSession
-from async_timeout import timeout
 
 from .controller import Controller
 from .zone import Zone
 
-DISCOVERY_MSG = b"IASD"
+DISCOVERY_MSG = b"IASD"  # cspell:disable-line
 DISCOVERY_PORT = 12107
 
 UPDATE_PORT = 7005
@@ -29,11 +26,11 @@ CHANGED_SYSTEM = b"iZoneChanged_System"
 CHANGED_ZONES = b"iZoneChanged_Zones"
 CHANGED_SCHEDULES = b"iZoneChanged_Schedules"
 
-DISCOVERY_TIMEOUT = 2.0
 DISCOVERY_SLEEP = 5.0 * 60.0
 DISCOVERY_RESCAN = 20.0
+RESCAN_COOLDOWN = 5.0
 
-_LOG = logging.getLogger("pizone.discovery")  # type: Logger
+_LOG = logging.getLogger("pizone.discovery")
 
 
 class LogExceptions:
@@ -42,10 +39,10 @@ class LogExceptions:
     def __init__(self, func: str) -> None:
         self.func = func
 
-    def __enter__(self):
+    def __enter__(self) -> "LogExceptions":
         return self
 
-    def __exit__(self, exc_type, exc_value, traceback):
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> bool:
         if exc_type:
             _LOG.error(
                 "Exception ignored when calling listener %s", self.func, exc_info=True
@@ -73,12 +70,12 @@ class Listener:
         """
 
     def controller_update(self, ctrl: Controller) -> None:
-        """Called when a system update message is recieved from the controller.
+        """Called when a system update message is received from the controller.
         Controller data will be set to new value.
         """
 
     def zone_update(self, ctrl: Controller, zone: Zone) -> None:
-        """Called when a zone update message is recieved from the controller
+        """Called when a zone update message is received from the controller
         Zone data will be set to new value.
         """
 
@@ -86,88 +83,96 @@ class Listener:
         """Called when the power monitor updates."""
 
 
-class DiscoveryService(ABC):
-    """Interface for discovery.
+class DiscoveryService:
+    """Discovery service: manages controller registry, listener fanout, and UDP scanning."""
 
-    This service is both a context manager, and an asynchronous context
-    manager. When used in the context manager version, the start
-    discovery and close will be called automatically when opening
-    and closing the context respectively.
-    """
-
-    @abstractmethod
-    def add_listener(self, listener: Listener) -> None:
-        """Add a listener.
-
-        All existing controllers will be passed to the listener."""
-
-    @abstractmethod
-    def remove_listener(self, listener: Listener) -> None:
-        """Remove a listener"""
-
-    @abstractmethod
-    async def start_discovery(self) -> None:
-        """Async version to start discovery.
-        Will return once discovery is started, but before any controllers
-        are found.
-        """
-
-    @abstractmethod
-    async def rescan(self) -> None:
-        """Trigger rescan for new controllers / update IP addresses of
-        existing controllers.
-
-        Returns immediately, listener will be called with any new
-        controllers or if reconnected.
-        """
-
-    @abstractmethod
-    async def close(self) -> None:
-        """Stop discovery and close all connections"""
-
-    @property
-    def is_closed(self) -> bool:
-        """Return true if closed"""
-
-    @property
-    def controllers(self) -> Dict[str, Controller]:
-        """Dictionary of all the currently discovered controllers"""
-
-
-class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
-    """Discovery protocol class. Not for external use."""
-
-    def __init__(self, session: ClientSession = None) -> None:
+    def __init__(self, session: ClientSession | None = None) -> None:
         """Start the discovery protocol using the supplied loop.
 
         raises:
             RuntimeError: If attempted to start the protocol when it is
                           already running.
         """
-        self._controllers = {}  # type: Dict[str, Controller]
-        self._disconnected = set()  # type: Set[str]
-        self._listeners = []  # type: List[Listener]
-        self._close_task = None  # type: Optional[Task]
+        self._controllers: dict[str, Controller] = {}
+        self._disconnected: set[str] = set()
+        self._listeners: list[Listener] = []
+        self._close_task: Task | None = None
 
         _LOG.info("Starting discovery protocol")
-        self.session = session
+        self._session = session
         self._own_session = session is None
 
-        self._transport = None  # type: Optional[DatagramTransport]
-
-        self._scan_condition = Condition()  # type: Condition
-
-        self._tasks = []  # type: List[Future]
+        self._transport: DatagramTransport | None = None
+
+        self._scan_condition = Condition()
+        self._last_rescan_time: float = 0.0
+
+        self._tasks: list[Task] = []
+
+        _srv = self
+
+        class _EventCoordinator(Listener):
+            """Fan-out adapter: dispatches controller/zone events to all registered listeners."""
+
+            # pylint: disable=protected-access
+
+            def controller_discovered(self, ctrl: Controller) -> None:
+                _LOG.info(
+                    "New controller found: id=%s ip=%s", ctrl.device_uid, ctrl.device_ip
+                )
+                for listener in _srv._listeners:
+                    with LogExceptions("controller_discovered"):
+                        listener.controller_discovered(ctrl)
+
+            def controller_disconnected(self, ctrl: Controller, ex: Exception) -> None:
+                _LOG.warning(
+                    "Connection to controller lost: id=%s ip=%s",
+                    ctrl.device_uid,
+                    ctrl.device_ip,
+                )
+                _srv._disconnected.add(ctrl.device_uid)
+                _srv.create_task(_srv._rescan())
+                for listener in _srv._listeners:
+                    with LogExceptions("controller_disconnected"):
+                        listener.controller_disconnected(ctrl, ex)
+
+            def controller_reconnected(self, ctrl: Controller) -> None:
+                _LOG.warning(
+                    "Controller reconnected: id=%s ip=%s",
+                    ctrl.device_uid,
+                    ctrl.device_ip,
+                )
+                _srv._disconnected.remove(ctrl.device_uid)
+                for listener in _srv._listeners:
+                    with LogExceptions("controller_reconnected"):
+                        listener.controller_reconnected(ctrl)
+
+            def controller_update(self, ctrl: Controller) -> None:
+                for listener in _srv._listeners:
+                    with LogExceptions("controller_update"):
+                        listener.controller_update(ctrl)
+
+            def zone_update(self, ctrl: Controller, zone: Zone) -> None:
+                for listener in _srv._listeners:
+                    with LogExceptions("zone_update"):
+                        listener.zone_update(ctrl, zone)
+
+            def power_update(self, ctrl: Controller) -> None:
+                for listener in _srv._listeners:
+                    with LogExceptions("power_update"):
+                        listener.power_update(ctrl)
+
+        self._event_coordinator: Listener = _EventCoordinator()
 
     # Async context manager interface
-    async def __aenter__(self) -> DiscoveryService:
+    async def __aenter__(self) -> "DiscoveryService":
         await self.start_discovery()
         return self
 
-    async def __aexit__(self, exc_type, exc_value, traceback):
+    async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         await self.close()
 
-    def _task_done_callback(self, task):
+    def _task_done_callback(self, task: Task) -> None:
         try:
             if task.exception():
                 _LOG.exception("Uncaught exception", exc_info=task.exception())
@@ -176,9 +181,9 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
         self._tasks.remove(task)
 
     # managing the task list.
-    def create_task(self, coro) -> Task:
+    def create_task(self, coro: Any) -> Task:
         """Create a task in the event loop. Keeps track of created tasks."""
-        task = asyncio.get_running_loop().create_task(coro)  # type: Task
+        task: Task = asyncio.get_running_loop().create_task(coro)
         self._tasks.append(task)
 
         task.add_done_callback(self._task_done_callback)
@@ -191,7 +196,7 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
         All existing controllers will be passed to the listener."""
         self._listeners.append(listener)
 
-        def callback():
+        def callback() -> None:
             for controller in self._controllers.values():
                 listener.controller_discovered(controller)
 
@@ -201,62 +206,36 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
         """Remove a listener"""
         self._listeners.remove(listener)
 
-    def controller_discovered(self, ctrl: Controller) -> None:
-        _LOG.info("New controller found: id=%s ip=%s", ctrl.device_uid, ctrl.device_ip)
-        for listener in self._listeners:
-            with LogExceptions("controller_discovered"):
-                listener.controller_discovered(ctrl)
+    # Non-context versions of starting.
+    async def start_discovery(self) -> None:
+        """Start discovery protocol. Creates UDP socket and begins scanning for devices."""
+        if self._own_session:
+            self._session = ClientSession()
 
-    def controller_disconnected(self, ctrl: Controller, ex: Exception) -> None:
-        _LOG.warning(
-            "Connection to controller lost: id=%s ip=%s",
-            ctrl.device_uid,
-            ctrl.device_ip,
-        )
-        self._disconnected.add(ctrl.device_uid)
-        self.create_task(self._rescan())
-        for listener in self._listeners:
-            with LogExceptions("controller_disconnected"):
-                listener.controller_disconnected(ctrl, ex)
+        _svc = self
 
-    def controller_reconnected(self, ctrl: Controller) -> None:
-        _LOG.warning(
-            "Controller reconnected: id=%s ip=%s", ctrl.device_uid, ctrl.device_ip
-        )
-        self._disconnected.remove(ctrl.device_uid)
-        for listener in self._listeners:
-            with LogExceptions("controller_reconnected"):
-                listener.controller_reconnected(ctrl)
+        class _UDPTransport(DatagramProtocol):
+            # pylint: disable=protected-access
+            def connection_made(self, transport: DatagramTransport) -> None:  # type: ignore
+                _svc._on_connection_made(transport)
 
-    def controller_update(self, ctrl: Controller) -> None:
-        for listener in self._listeners:
-            with LogExceptions("controller_update"):
-                listener.controller_update(ctrl)
-
-    def zone_update(self, ctrl: Controller, zone: Zone) -> None:
-        for listener in self._listeners:
-            with LogExceptions("zone_update"):
-                listener.zone_update(ctrl, zone)
+            def datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
+                _svc._on_datagram_received(data, addr)
 
-    def power_update(self, ctrl: Controller) -> None:
-        for listener in self._listeners:
-            with LogExceptions("power_update"):
-                listener.power_update(ctrl)
+            def connection_lost(self, exc: Exception | None) -> None:
+                _svc._on_connection_lost(exc)
 
-    @property
-    def controllers(self) -> Dict[str, Controller]:
-        """Dictionary of all the currently discovered controllers"""
-        return self._controllers
+            def error_received(self, exc: Exception) -> None:
+                _svc._on_error_received(exc)
 
-    # Non-context versions of starting.
-    async def start_discovery(self) -> None:
-        if self._own_session:
-            self.session = ClientSession()
         await asyncio.get_running_loop().create_datagram_endpoint(
-            lambda: self, local_addr=("0.0.0.0", UPDATE_PORT), allow_broadcast=True
+            _UDPTransport,
+            local_addr=("0.0.0.0", UPDATE_PORT),
+            allow_broadcast=True,
         )
 
-    def connection_made(self, transport: DatagramTransport) -> None:  # type: ignore  # noqa: E501
+    # Private callbacks invoked by _UDPTransport.
+    def _on_connection_made(self, transport: DatagramTransport) -> None:
         if self._close_task:
             transport.close()
             return
@@ -265,7 +244,7 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
         self._transport = transport
         self.create_task(self._scan_loop())
 
-    def _get_broadcasts(self):
+    def _get_broadcasts(self) -> Any:
         for ifaddr in map(netifaces.ifaddresses, netifaces.interfaces()):
             inetaddrs = ifaddr.get(netifaces.AF_INET)
             if not inetaddrs:
@@ -275,7 +254,8 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
                 if broadcast:
                     yield broadcast
 
-    def _send_broadcasts(self):
+    def _send_broadcasts(self) -> None:
+        assert self._transport is not None, "Discovery transport is not ready"
         for broadcast in self._get_broadcasts():
             _LOG.debug("Sending discovery message to addr %s", broadcast)
             self._transport.sendto(DISCOVERY_MSG, (broadcast, DISCOVERY_PORT))
@@ -287,7 +267,7 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
             self._send_broadcasts()
 
             try:
-                async with timeout(
+                async with asyncio.timeout(
                     DISCOVERY_RESCAN if self._disconnected else DISCOVERY_SLEEP
                 ):
                     async with self._scan_condition:
@@ -298,16 +278,62 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
             if self._close_task:
                 return
 
-    async def rescan(self) -> None:
-        if self.is_closed:
-            raise ConnectionError("Already closed")
-        _LOG.debug("Manual rescan of controllers triggered.")
-        await self._rescan()
-
     async def _rescan(self) -> None:
         async with self._scan_condition:
             self._scan_condition.notify()
 
+    async def _maybe_rescan(self) -> None:
+        """Trigger a rescan only if outside the cool-down window."""
+        now = asyncio.get_running_loop().time()
+        if now - self._last_rescan_time >= RESCAN_COOLDOWN:
+            self._last_rescan_time = now
+            await self._rescan()
+
+    async def fetch_controller(
+        self, uid: str, timeout: float | None = None
+    ) -> Controller | None:
+        """Return the controller with *uid*, optionally waiting up to *timeout* seconds."""
+        if uid in self._controllers:
+            return self._controllers[uid]
+        if timeout is None:
+            return None
+
+        ready = asyncio.Event()
+
+        class _WaitForUidListener(Listener):
+            def controller_discovered(self, ctrl: Controller) -> None:  # noqa: N805
+                if ctrl.device_uid == uid:
+                    ready.set()
+
+        listener = _WaitForUidListener()
+        self.add_listener(listener)
+        try:
+            # Re-check after registering the listener (add_listener uses call_soon,
+            # so no race possible in the single-threaded event loop).
+            if uid in self._controllers:
+                return self._controllers[uid]
+
+            await self._maybe_rescan()
+
+            with suppress(TimeoutError):
+                async with asyncio.timeout(timeout):
+                    await ready.wait()
+        finally:
+            self.remove_listener(listener)
+
+        return self._controllers.get(uid)
+
+    async def fetch_controllers(
+        self, timeout: float | None = None
+    ) -> dict[str, Controller]:
+        """Return all known controllers, optionally waiting for discovery to settle."""
+        if timeout is None:
+            return dict(self._controllers)
+
+        await self._maybe_rescan()
+        await asyncio.sleep(timeout)
+        return dict(self._controllers)
+
     # Closing the connection
     async def close(self) -> None:
         """Close the transport"""
@@ -322,12 +348,12 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
         for i in self._tasks:
             i.cancel()
 
-        if self._own_session and self.session:
-            await self.session.close()
+        if self._own_session and self._session:
+            await self._session.close()
 
         await asyncio.wait(self._tasks)
 
-    def connection_lost(self, exc):
+    def _on_connection_lost(self, exc: Exception | None) -> None:
         _LOG.debug("Connection Lost")
         if not self._close_task:
             _LOG.error("Connection Lost unexpectedly: %s", repr(exc))
@@ -335,20 +361,26 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
 
     @property
     def is_closed(self) -> bool:
+        """Check if the discovery service is closed."""
         if self._transport:
             return self._transport.is_closing()
         return self._close_task is not None
 
-    def error_received(self, exc):
-        _LOG.warning("Error passed and ignored to error_recieved", exc_info=True)
+    @property
+    def session(self) -> Any:
+        """Return the aiohttp session used for HTTP requests."""
+        return self._session
+
+    def _on_error_received(self, _: Exception) -> None:
+        _LOG.warning("Error passed and ignored to error_received", exc_info=True)
 
-    def _find_by_addr(self, addr: str) -> Optional[Controller]:
+    def _find_by_addr(self, addr: tuple[str, int]) -> Controller | None:
         for _, ctrl in self._controllers.items():
             if ctrl.device_ip == addr[0]:
                 return ctrl
         return None
 
-    async def _wrap_update(self, coro):
+    async def _wrap_update(self, coro: Any) -> None:
         try:
             await coro
         except ConnectionError:
@@ -356,13 +388,13 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
                 "Unable to complete %s due to connection error", coro, exc_info=True
             )
 
-    def datagram_received(self, data, addr):
-        _LOG.debug("Datagram Recieved %s", data)
+    def _on_datagram_received(self, data: bytes, addr: tuple[str, int]) -> None:
+        _LOG.debug("Datagram Received %s", data)
         if self._close_task:
             return
         self._process_datagram(data, addr)
 
-    def _process_datagram(self, data, addr):
+    def _process_datagram(self, data: bytes, addr: tuple[str, int]) -> None:
         if data in (DISCOVERY_MSG, CHANGED_SCHEDULES):
             # ignore
             pass
@@ -377,9 +409,9 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
                 # pylint: disable=protected-access
                 self.create_task(self._wrap_update(ctrl._refresh_zones()))
         else:
-            self._discovery_recieved(data)
+            self._discovery_received(data)
 
-    def _discovery_recieved(self, data):
+    def _discovery_received(self, data: bytes) -> None:
         message = data.decode().split(",")
         if (
             len(message) < 3
@@ -403,29 +435,31 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
                 device_uid, device_ip, is_v2, is_ipower
             )
 
-            async def initialize_controller():
+            async def initialize_controller() -> None:
                 try:
                     await controller._initialize()  # noqa: E501
                 except ConnectionError as ex:
                     _LOG.warning(
-                        "Can't connect to discovered server at IP '%s'"
-                        " exception: %s",
+                        "Can't connect to discovered server at IP '%s' exception: %s",
                         device_ip,
                         repr(ex),
                     )
                     return
 
                 self._controllers[device_uid] = controller
-                self.controller_discovered(controller)
+                self._event_coordinator.controller_discovered(controller)
 
             self.create_task(initialize_controller())
         else:
             controller = self._controllers[device_uid]
             controller._refresh_address(device_ip)
 
-    def _create_controller(self, device_uid, device_ip, is_v2, is_ipower):
+    def _create_controller(
+        self, device_uid: str, device_ip: str, is_v2: bool, is_ipower: bool
+    ) -> Controller:
         return Controller(
             self,
+            self._event_coordinator,
             device_uid=device_uid,
             device_ip=device_ip,
             is_v2=is_v2,
@@ -433,12 +467,14 @@ class _DiscoveryServiceImpl(DiscoveryService, DatagramProtocol, Listener):
         )
 
 
-def discovery(*listeners: Listener, session: ClientSession = None) -> DiscoveryService:
+def discovery(
+    *listeners: Listener, session: ClientSession | None = None
+) -> DiscoveryService:
     """Create discovery service. Returned object is a asynchronous
     context manager so can be used with 'async with' statement.
     Alternately call start_discovery or start_discovery_async to commence
     the discovery process."""
-    service = _DiscoveryServiceImpl(session=session)
+    service = DiscoveryService(session=session)
     for listener in listeners:
         service.add_listener(listener)
     return service

pizone/power.py

@@ -9,8 +9,7 @@ from __future__ import annotations
 import json
 import logging
 from enum import IntEnum, unique
-from typing import Any, Dict, Iterable, List, Optional, Set, Tuple
-
+from typing import Any, Dict, Iterable, List, Set, Tuple
 
 _LOG = logging.getLogger("pizone.power")
 
@@ -35,7 +34,7 @@ class BatteryLevel(IntEnum):
 class PowerChannel:
     """Channel within power device"""
 
-    def __init__(self, device: PowerDevice, index: int):
+    def __init__(self, device: PowerDevice, index: int) -> None:
         self._device = device
         self._index = index
 
@@ -70,7 +69,7 @@ class PowerChannel:
         return self._config["Name"]
 
     @property
-    def group_number(self) -> Optional[int]:
+    def group_number(self) -> int | None:
         """Group number"""
         num = self._config["GrNo"]
         return num if num < 255 else None
@@ -94,7 +93,7 @@ class PowerChannel:
 class PowerDevice:
     """Device for power information."""
 
-    def __init__(self, power: Power, index: int):
+    def __init__(self, power: Power, index: int) -> None:
         self._power = power
         self._index = index
         self._channels = tuple(PowerChannel(self, i) for i in range(0, 3))
@@ -138,7 +137,7 @@ class PowerDevice:
 class PowerGroup:
     """Grouped power devices"""
 
-    def __init__(self, power: Power, channels: Iterable[PowerChannel]):
+    def __init__(self, power: Power, channels: Iterable[PowerChannel]) -> None:
         self._power = power
         self._channels = tuple(channels)
         # get unique devices
@@ -171,13 +170,13 @@ class PowerGroup:
 class Power:
     """Contains power information."""
 
-    def __init__(self, controller) -> None:
+    def __init__(self, controller: Any) -> None:
         """Init function."""
-        self._controller = controller  # type: ignore
-        self._config = {}  # type: Dict[str, Any]
-        self._status = {"LastReadingNo": -1}  # type: Dict[str, Any]
+        self._controller = controller
+        self._config: Dict[str, Any] = {}
+        self._status: Dict[str, Any] = {"LastReadingNo": -1}
         self._devices = tuple(PowerDevice(self, i) for i in range(0, 5))
-        self._groups = None  # type: Optional[Tuple[PowerGroup, ...]]
+        self._groups: Tuple[PowerGroup, ...] | None = None
 
     async def init(self) -> None:
         """Initialise the power settings."""
@@ -191,7 +190,7 @@ class Power:
 
     async def refresh(self) -> bool:
         """Refreshes the power usage data."""
-        status = await self._do_request(2, "PowerMonitorStatus")  # type: Dict[str, Any]
+        status: Dict[str, Any] = await self._do_request(2, "PowerMonitorStatus")
 
         if status["LastReadingNo"] == self._status["LastReadingNo"]:
             return False
@@ -243,6 +242,6 @@ class Power:
         return self._devices
 
     @property
-    def groups(self) -> Optional[Tuple[PowerGroup, ...]]:
+    def groups(self) -> Tuple[PowerGroup, ...] | None:
         """Available power groups."""
         return self._groups

pizone/version.py

@@ -1,5 +1,24 @@
-# coding: utf-8
-# file generated by setuptools_scm
+# file generated by vcs-versioning
 # don't change, don't track in version control
-version = '1.2.9'
-version_tuple = (1, 2, 9)
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.2.10'
+__version_tuple__ = version_tuple = (1, 2, 10)
+
+__commit_id__ = commit_id = None

pizone/zone.py

@@ -5,7 +5,7 @@ Various properties allow interogation and setting of zone data.
 """
 
 from enum import Enum
-from typing import Dict, Optional, Union
+from typing import Any, Dict, Union
 
 
 class Zone:
@@ -37,8 +37,8 @@ class Zone:
     DictValue = Union[str, int, float]
     ZoneData = Dict[str, DictValue]
 
-    def __init__(self, controller, index: int) -> None:
-        self._zone_data = {}  # type: Dict
+    def __init__(self, controller: Any, index: int) -> None:
+        self._zone_data: Zone.ZoneData = {}
         self._index = index
         self._controller = controller
 
@@ -53,7 +53,7 @@ class Zone:
         return self._get_zone_state("Name")
 
     @property
-    def type(self) -> "Type":
+    def type(self) -> "Zone.Type":
         """This indicates the type of the zone. Possible values are:
         'auto' – the zone has temperature control enabled
         'opcl' – the zone is open/close only
@@ -62,7 +62,7 @@ class Zone:
         return self.Type(self._get_zone_state("Type"))
 
     @property
-    def mode(self) -> "Mode":
+    def mode(self) -> "Zone.Mode":
         """This indicates the current mode the zone is in. Possible values are:
         'open' – the zone is currently open
         'close' – the zone is currently closed
@@ -71,12 +71,12 @@ class Zone:
         return self.Mode(self._get_zone_state("Mode"))
 
     @property
-    def temp_setpoint(self) -> Optional[float]:
+    def temp_setpoint(self) -> float | None:
         """Temp setpoint in degrees C."""
         return self._get_zone_state("SetPoint") or None
 
     @property
-    def temp_current(self) -> Optional[float]:
+    def temp_current(self) -> float | None:
         """Current zone temperature"""
         return self._get_zone_state("Temp") or None
 
@@ -142,7 +142,7 @@ class Zone:
         self._zone_data["SetPoint"] = value
         self._fire_listeners()
 
-    async def set_mode(self, value: Mode) -> None:
+    async def set_mode(self, value: "Zone.Mode") -> None:
         """Set the current zone mode.
         Possible values are:
         'open' – the zone is currently open
@@ -159,7 +159,7 @@ class Zone:
             self._zone_data["Mode"] = value.value
         self._fire_listeners()
 
-    def _update_zone(self, zone_data, notify: bool = True):
+    def _update_zone(self, zone_data: "Zone.ZoneData", notify: bool = True) -> None:
         if zone_data["Index"] != self._index:
             raise AttributeError("Can't change index of existing zone.")
         self._zone_data = zone_data
@@ -168,13 +168,13 @@ class Zone:
 
     def _fire_listeners(self) -> None:
         # pylint: disable=protected-access
-        self._controller._discovery.zone_update(self._controller, self)
+        self._controller._event_coordinator.zone_update(self._controller, self)
 
-    def _get_zone_state(self, state):
+    def _get_zone_state(self, state: str) -> Any:
         self._controller._ensure_connected()  # pylint: disable=protected-access  # noqa
         return self._zone_data[state]
 
-    async def _send_command(self, command, data: Union[str, float, int]):
+    async def _send_command(self, command: str, data: Union[str, float, int]) -> None:
         send_data = {command: {"ZoneNo": str(self._index + 1), "Command": str(data)}}
         # pylint: disable=protected-access
         await self._controller._send_command_async(command, send_data)

{python_izone-1.2.9.dist-info → python_izone-1.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-izone
-Version: 1.2.9
+Version: 1.2.10
 Summary: A python interface to the iZone airconditioner controller
 Home-page: https://github.com/Swamp-Ig/pizone
 Author: Penny Wood
@@ -8,25 +8,25 @@ Author-email: pypl@ninjateaparty.com
 Keywords: iZone,IoT
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Home Automation
 Classifier: Topic :: System :: Hardware
-Requires-Python: >=3.9
+Requires-Python: >=3.14
 Description-Content-Type: text/markdown
 License-File: licence.txt
-Requires-Dist: aiohttp (>=3.4)
-Requires-Dist: netifaces
-Requires-Dist: async-timeout
-Provides-Extra: all
-Requires-Dist: pytest (>=6.2.2) ; extra == 'all'
-Requires-Dist: pytest-aio ; extra == 'all'
-Requires-Dist: pytest-aiohttp ; extra == 'all'
+Requires-Dist: aiohttp>=3.10
+Requires-Dist: netifaces>=0.11
 Provides-Extra: test
-Requires-Dist: pytest (>=6.2.2) ; extra == 'test'
-Requires-Dist: pytest-aio ; extra == 'test'
-Requires-Dist: pytest-aiohttp ; extra == 'test'
+Requires-Dist: pytest>=6.2.2; extra == "test"
+Requires-Dist: pytest-aio; extra == "test"
+Requires-Dist: pytest-aiohttp; extra == "test"
+Provides-Extra: all
+Requires-Dist: pytest>=6.2.2; extra == "all"
+Requires-Dist: pytest-aio; extra == "all"
+Requires-Dist: pytest-aiohttp; extra == "all"
+Dynamic: license-file
 
 
 # piZone - python interface to iZone aircon system

python_izone-1.2.10.dist-info/RECORD

@@ -0,0 +1,11 @@
+pizone/__init__.py,sha256=MSm2bF2eZCqO4USVob4IHaWwdeG-ygvdKQJxbTeqDW0,507
+pizone/controller.py,sha256=d6m8rWgPQ9MArC_Z6ejkcQIvmLoSPMJRGtu78S84m7o,20736
+pizone/discovery.py,sha256=I9-HM40O6PWzRriRJHLgDuv4MNA16rtlKvqbUEknWsA,16809
+pizone/power.py,sha256=BkgOQXhK39CGYUwgpMHrR37lwztfc-ItMkH7Ay6mBoA,6694
+pizone/version.py,sha256=MHv5TrXn6T-L85hrOYm8mAeGoL3s8Fammbmt6HNhexA,522
+pizone/zone.py,sha256=4DEaS_iFiFNXPQ3GplKiKlmyRPGtJj4ek5OZQKwD1Ng,6463
+python_izone-1.2.10.dist-info/licenses/licence.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_izone-1.2.10.dist-info/METADATA,sha256=K4m_Ix8hRG3z3gFGcz2IRkIUXtzii3gG_17C2S75yOM,1365
+python_izone-1.2.10.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_izone-1.2.10.dist-info/top_level.txt,sha256=VRPVB7Bq60Bqh6N4d-U1xvOkXcQbsiN1zxnrajPL2Xg,7
+python_izone-1.2.10.dist-info/RECORD,,

{python_izone-1.2.9.dist-info → python_izone-1.2.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (82.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

python_izone-1.2.9.dist-info/RECORD

@@ -1,11 +0,0 @@
-pizone/__init__.py,sha256=TG3TLQTOcvr74j-OrDyqFHkLRabrgE30N8k-l5CcrHk,487
-pizone/controller.py,sha256=Ie6zlXK82Gu-TQFB1vQNS8TOF_KgKGPZei0xwBcJ5U0,20108
-pizone/discovery.py,sha256=VCfd422j1DmKvZ-nRs2bZ3KSklSgvB2gZKkOGHhHQOo,14832
-pizone/power.py,sha256=LnGlLLo51sBikVJr7v8k2h1W-1a4qai30To1JmkJmTg,6733
-pizone/version.py,sha256=bntNoig_UKPNqaLflAKmPVAKv-l0ffT7k1DuXIq23pc,142
-pizone/zone.py,sha256=GsjtIczJ-A1YBDhP5X28e4UWmKj_-fm07vYqGHnt7JM,6393
-python_izone-1.2.9.dist-info/METADATA,sha256=dxzG2cY3NFpwLCBGV7kcXqAHaUDobud30J7YkcT9yJc,1377
-python_izone-1.2.9.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-python_izone-1.2.9.dist-info/licence.txt,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-python_izone-1.2.9.dist-info/top_level.txt,sha256=VRPVB7Bq60Bqh6N4d-U1xvOkXcQbsiN1zxnrajPL2Xg,7
-python_izone-1.2.9.dist-info/RECORD,,