python-izone 1.2.9__tar.gz → 1.2.10__tar.gz

{python-izone-1.2.9 → python_izone-1.2.10}/.github/workflows/main.yml

@@ -8,12 +8,12 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.9", "3.10"]
+        python-version: ["3.14"]
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
       - name: Install dependencies
@@ -31,7 +31,7 @@ jobs:
           pip install build
           python -m build
       - name: Publish package
-        if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags') && matrix.python-version == '3.9'
+        if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags') && matrix.python-version == '3.14'
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           password: ${{ secrets.PYPI_API_TOKEN }}

python_izone-1.2.10/.pre-commit-config.yaml

@@ -0,0 +1,6 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 25.1.0
+    hooks:
+      - id: black
+        args: [--check, --diff]

{python-izone-1.2.9 → python_izone-1.2.10}/.pylintrc

@@ -82,15 +82,11 @@ persistent=yes
 
 # Minimum Python version to use for version dependent checks. Will default to
 # the version used to run pylint.
-py-version=3.9
+py-version=3.14
 
 # Discover python modules and packages in the file system subtree.
 recursive=no
 
-# When enabled, pylint would attempt to guess common misconfiguration and emit
-# user-friendly hints instead of false-positive error messages.
-suggestion-mode=yes
-
 # Allow loading of arbitrary C extensions. Extensions are imported into the
 # active Python interpreter and may run arbitrary code.
 unsafe-load-any-extension=no
@@ -369,8 +365,8 @@ min-public-methods=2
 [EXCEPTIONS]
 
 # Exceptions that will emit a warning when caught.
-overgeneral-exceptions=BaseException,
-                       Exception
+overgeneral-exceptions=builtins.BaseException,
+                       builtins.Exception
 
 
 [FORMAT]

{python-izone-1.2.9 → python_izone-1.2.10}/.vscode/settings.json

@@ -8,7 +8,19 @@
     "python.linting.pylintEnabled": true,
     "python.linting.flake8Enabled": false,
     "python.linting.mypyEnabled": true,
-    "python.pythonPath": "venv\\Scripts\\python.exe",
+    "python.defaultInterpreterPath": "${workspaceFolder}/.venv/bin/python",
     "python.globalModuleInstallation": false,
-    "python.formatting.provider": "black"
+    "python.formatting.provider": "black",
+    "cSpell.words": [
+        "inetaddrs",
+        "inetaddr",
+        "ifaddresses",
+        "rescan",
+        "pizone",
+        "ipower",
+        "COOLDOWN",
+        "coro",
+        "datagram",
+        "fanout"
+    ]
 }

{python-izone-1.2.9 → python_izone-1.2.10}/PKG-INFO

@@ -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,16 +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.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"
 Provides-Extra: all
-License-File: licence.txt
+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/pizone/__init__.py

@@ -0,0 +1,22 @@
+"""Interface to the iZone airconditioner controller
+
+Interaction mostly through the Controller and Zone classes.
+"""
+
+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",
+]

{python-izone-1.2.9 → python_izone-1.2.10}/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