aioairzone-cloud 0.0.3__py3-none-any.whl

aioairzone_cloud/__init__.py

@@ -0,0 +1 @@
+"""Airzone Cloud API library."""

aioairzone_cloud/cloudapi.py

@@ -0,0 +1,372 @@
+"""Airzone Cloud API."""
+from __future__ import annotations
+
+import logging
+import urllib.parse
+from typing import Any, cast
+
+from aiohttp import ClientConnectorError, ClientSession
+from aiohttp.client_reqrep import ClientResponse
+
+from .common import ConnectionOptions
+from .const import (
+    API_AUTH_LOGIN,
+    API_AUTH_REFRESH_TOKEN,
+    API_AZ_SYSTEM,
+    API_AZ_ZONE,
+    API_CONFIG,
+    API_DEVICE_ID,
+    API_DEVICE_TYPE,
+    API_DEVICES,
+    API_EMAIL,
+    API_INSTALLATION_ID,
+    API_INSTALLATIONS,
+    API_PASSWORD,
+    API_REFRESH_TOKEN,
+    API_STATUS,
+    API_TOKEN,
+    API_URL,
+    API_USER,
+    API_USER_LOGOUT,
+    API_V1,
+    API_WS,
+    AZD_INSTALLATIONS,
+    AZD_SYSTEMS,
+    AZD_WEBSERVERS,
+    AZD_ZONES,
+    HEADER_AUTHORIZATION,
+    HEADER_BEARER,
+    HTTP_CALL_TIMEOUT,
+)
+from .device import Device
+from .exceptions import LoginError, TokenRefreshError
+from .installation import Installation
+from .system import System
+from .webserver import WebServer
+from .zone import Zone
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AirzoneCloudApi:
+    """Airzone Cloud API."""
+
+    def __init__(
+        self,
+        aiohttp_session: ClientSession,
+        options: ConnectionOptions,
+    ):
+        """Airzone Cloud API init."""
+        self.aiohttp_session = aiohttp_session
+        self.installations: list[Installation] = []
+        self.options = options
+        self.refresh_token: str | None = None
+        self.systems: list[System] = []
+        self.token: str | None = None
+        self.webservers: list[WebServer] = []
+        self.zones: list[Zone] = []
+
+    async def api_request(
+        self, method: str, path: str, json: Any | None = None
+    ) -> dict[str, Any]:
+        """Airzone Cloud API request."""
+        _LOGGER.debug("aiohttp request: /%s (params=%s)", path, json)
+        headers: dict[str, str] = {}
+        if self.token:
+            headers[HEADER_AUTHORIZATION] = f"{HEADER_BEARER} {self.token}"
+        resp: ClientResponse = await self.aiohttp_session.request(
+            method,
+            f"{API_URL}/{path}",
+            headers=headers,
+            json=json,
+            raise_for_status=True,
+            timeout=HTTP_CALL_TIMEOUT,
+        )
+        resp_json = await resp.json(content_type=None)
+        _LOGGER.debug("aiohttp response: %s", resp_json)
+        return cast(dict, resp_json)
+
+    async def api_get_device_config(self, device: Device) -> dict[str, Any]:
+        """Request API device config data."""
+        dev_id = urllib.parse.quote(device.get_id())
+
+        params = {
+            API_INSTALLATION_ID: device.get_installation(),
+        }
+        dev_params = urllib.parse.urlencode(params)
+
+        return await self.api_request(
+            "GET",
+            f"{API_V1}/{API_DEVICES}/{dev_id}/{API_CONFIG}?{dev_params}",
+        )
+
+    async def api_get_device_status(self, device: Device) -> dict[str, Any]:
+        """Request API device status data."""
+        dev_id = urllib.parse.quote(device.get_id())
+
+        params = {
+            API_INSTALLATION_ID: device.get_installation(),
+        }
+        dev_params = urllib.parse.urlencode(params)
+
+        return await self.api_request(
+            "GET",
+            f"{API_V1}/{API_DEVICES}/{dev_id}/{API_STATUS}?{dev_params}",
+        )
+
+    async def api_get_installation(self, installation: Installation) -> dict[str, Any]:
+        """Request API installation data."""
+        inst_id = urllib.parse.quote(installation.get_id())
+        return await self.api_request(
+            "GET",
+            f"{API_V1}/{API_INSTALLATIONS}/{inst_id}",
+        )
+
+    async def api_get_installations(self) -> dict[str, Any]:
+        """Request API installations data."""
+        return await self.api_request(
+            "GET",
+            f"{API_V1}/{API_INSTALLATIONS}",
+        )
+
+    async def api_get_user(self) -> dict[str, Any]:
+        """Request API user data."""
+        return await self.api_request(
+            "GET",
+            f"{API_V1}/{API_USER}",
+        )
+
+    async def api_get_webserver(
+        self, webserver: WebServer, devices: bool
+    ) -> dict[str, Any]:
+        """Request API webserver data."""
+        ws_id = urllib.parse.quote(webserver.get_id())
+
+        params: dict[str, Any] = {
+            API_INSTALLATION_ID: webserver.get_installation(),
+        }
+        if devices:
+            params[API_DEVICES] = 1
+        ws_params = urllib.parse.urlencode(params)
+
+        return await self.api_request(
+            "GET",
+            f"{API_V1}/{API_DEVICES}/{API_WS}/{ws_id}/{API_STATUS}?{ws_params}",
+        )
+
+    async def login(self) -> None:
+        """Perform Airzone Cloud API login."""
+        if self.token:
+            await self.logout()
+        resp = await self.api_request(
+            "POST",
+            f"{API_V1}/{API_AUTH_LOGIN}",
+            {
+                API_EMAIL: self.options.username,
+                API_PASSWORD: self.options.password,
+            },
+        )
+        _LOGGER.debug("login resp: %s", resp)
+        if resp.keys() < {API_TOKEN, API_REFRESH_TOKEN}:
+            raise LoginError
+        self.token = resp[API_TOKEN]
+        self.refresh_token = resp[API_REFRESH_TOKEN]
+
+    async def logout(self) -> None:
+        """Perform Airzone Cloud API logout."""
+        try:
+            if self.token:
+                await self.api_request(
+                    "GET",
+                    f"{API_V1}/{API_USER_LOGOUT}",
+                )
+        except ClientConnectorError:
+            pass
+        finally:
+            self.refresh_token = None
+            self.token = None
+
+    async def token_refresh(self) -> None:
+        """Perform Airzone Cloud API token refresh."""
+        if self.token and self.refresh_token:
+            resp = await self.api_request(
+                "POST",
+                f"{API_V1}/{API_AUTH_REFRESH_TOKEN}",
+                {
+                    API_REFRESH_TOKEN: self.refresh_token,
+                },
+            )
+            _LOGGER.debug("refresh resp: %s", resp)
+            if resp.keys() < {API_TOKEN, API_REFRESH_TOKEN}:
+                raise TokenRefreshError
+            self.token = resp[API_TOKEN]
+            self.refresh_token = resp[API_REFRESH_TOKEN]
+
+    def data(self) -> dict[str, Any]:
+        """Return Airzone Cloud data."""
+        data: dict[str, Any] = {}
+
+        if self.installations:
+            installations: dict[str, Any] = {}
+            for installation in self.installations:
+                installations[installation.get_id()] = installation.data()
+            data[AZD_INSTALLATIONS] = installations
+
+        if self.systems:
+            systems: dict[str, Any] = {}
+            for system in self.systems:
+                systems[system.get_id()] = system.data()
+            data[AZD_SYSTEMS] = systems
+
+        if self.webservers:
+            webservers: dict[str, Any] = {}
+            for webserver in self.webservers:
+                webservers[webserver.get_id()] = webserver.data()
+            data[AZD_WEBSERVERS] = webservers
+
+        if self.zones:
+            zones: dict[str, Any] = {}
+            for zone in self.zones:
+                zones[zone.get_id()] = zone.data()
+            data[AZD_ZONES] = zones
+
+        return data
+
+    def get_installation_id(self, inst_id: str) -> Installation | None:
+        """Return Airzone Cloud Installation by ID."""
+        for inst in self.installations:
+            if inst_id == inst.get_id():
+                return inst
+        return None
+
+    def get_system_id(self, sys_id: str) -> System | None:
+        """Return Airzone Cloud System by ID."""
+        for system in self.systems:
+            if sys_id == system.get_id():
+                return system
+        return None
+
+    def get_webserver_id(self, ws_id: str) -> WebServer | None:
+        """Return Airzone Cloud WebServer by ID."""
+        for ws in self.webservers:
+            if ws_id == ws.get_id():
+                return ws
+        return None
+
+    def get_zone_id(self, zone_id: str) -> Zone | None:
+        """Return Airzone Cloud Zone by ID."""
+        for zone in self.zones:
+            if zone_id == zone.get_id():
+                return zone
+        return None
+
+    async def list_installations(self) -> list[Installation]:
+        """Return Airzone Cloud installations list."""
+        inst_list: list[Installation] = []
+
+        inst_data = await self.api_get_installations()
+        for inst in inst_data[API_INSTALLATIONS]:
+            inst_list.append(Installation(inst))
+
+        return inst_list
+
+    def select_installation(self, inst: Installation) -> None:
+        """Select single Airzone Cloud installation."""
+        self.installations = [inst]
+        for ws_id in inst.get_webservers():
+            if not self.get_webserver_id(ws_id):
+                ws = WebServer(inst.get_id(), ws_id)
+                self.webservers.append(ws)
+
+    def set_system_zones_data(self, system: System):
+        """Set slave zones modes from master zone."""
+        modes = system.get_modes()
+        installation_id = system.get_installation()
+        system_id = system.get_id()
+        system_num = system.get_system()
+        for zone in self.zones:
+            zone.set_system_id(system_id)
+            is_slave = zone.get_master() is False
+            if (
+                is_slave
+                and modes
+                and zone.get_installation() == installation_id
+                and zone.get_system() == system_num
+            ):
+                zone.set_modes(modes)
+
+    async def update_installations(self) -> None:
+        """Update Airzone Cloud installations from API."""
+        installations_data = await self.api_get_installations()
+        for installation_data in installations_data[API_INSTALLATIONS]:
+            if not self.get_installation_id(installation_data[API_INSTALLATION_ID]):
+                installation = Installation(installation_data)
+                if installation:
+                    self.installations.append(installation)
+                    for ws_id in installation.get_webservers():
+                        if not self.get_webserver_id(ws_id):
+                            ws = WebServer(installation.get_id(), ws_id)
+                            self.webservers.append(ws)
+
+    async def update_system(self, system: System) -> None:
+        """Update Airzone Cloud System from API."""
+        device_data = await self.api_get_device_status(system)
+        system.update(device_data)
+
+    async def update_system_id(self, sys_id: str) -> None:
+        """Update Airzone Cloud System by ID."""
+        system = self.get_system_id(sys_id)
+        if system:
+            await self.update_system(system)
+
+    async def update_systems(self) -> None:
+        """Update all Airzone Cloud Systems."""
+        for system in self.systems:
+            await self.update_system(system)
+
+    async def update_webserver(self, ws: WebServer, devices: bool) -> None:
+        """Update Airzone Cloud WebServer from API."""
+        ws_data = await self.api_get_webserver(ws, devices)
+        ws.update(ws_data)
+        if devices:
+            for device_data in ws_data[API_DEVICES]:
+                if API_AZ_ZONE == device_data[API_DEVICE_TYPE]:
+                    if not self.get_zone_id(device_data[API_DEVICE_ID]):
+                        zone = Zone(ws.get_installation(), ws.get_id(), device_data)
+                        if zone:
+                            self.zones.append(zone)
+                elif API_AZ_SYSTEM == device_data[API_DEVICE_TYPE]:
+                    if not self.get_zone_id(device_data[API_DEVICE_ID]):
+                        system = System(ws.get_installation(), ws.get_id(), device_data)
+                        if system:
+                            self.systems.append(system)
+
+    async def update_webserver_id(self, ws_id: str, devices: bool = False) -> None:
+        """Update Airzone Cloud WebServer by ID."""
+        ws = self.get_webserver_id(ws_id)
+        if ws:
+            await self.update_webserver(ws, devices)
+
+    async def update_webservers(self, devices: bool = True) -> None:
+        """Update all Airzone Cloud WebServers."""
+        for ws in self.webservers:
+            await self.update_webserver(ws, devices)
+
+    async def update_zone(self, zone: Zone) -> None:
+        """Update Airzone Cloud Zone from API."""
+        device_data = await self.api_get_device_status(zone)
+        zone.update(device_data)
+
+    async def update_zone_id(self, zone_id: str) -> None:
+        """Update Airzone Cloud Zone by ID."""
+        zone = self.get_zone_id(zone_id)
+        if zone:
+            await self.update_zone(zone)
+
+    async def update_zones(self) -> None:
+        """Update all Airzone Cloud Zones."""
+        for zone in self.zones:
+            await self.update_zone(zone)
+
+        for system in self.systems:
+            self.set_system_zones_data(system)

aioairzone_cloud/common.py

@@ -0,0 +1,69 @@
+"""Airzone Cloud API common code."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+@dataclass
+class ConnectionOptions:
+    """Airzone Cloud options for connection."""
+
+    username: str
+    password: str
+
+
+class OperationMode(int, Enum):
+    """Airzone Cloud operation modes."""
+
+    STOP = 0
+    AUTO = 1
+    COOLING = 2
+    HEATING = 3
+    VENTILATION = 4
+    DRY = 5
+    EMERGENCY_HEAT = 6
+    HEAT_AIR = 7
+    HEAT_RADIANT = 8
+    HEAT_COMBINED = 9
+    COOLING_AIR = 10
+    COOLING_RADIANT = 11
+    COOLING_COMBINED = 12
+
+    def is_cool(self) -> bool:
+        """Return if mode is Cool."""
+        return self.value in [
+            self.COOLING,
+            self.COOLING_AIR,
+            self.COOLING_COMBINED,
+            self.COOLING_RADIANT,
+        ]
+
+    def is_dry(self) -> bool:
+        """Return if mode is Dry."""
+        return self.value in [self.DRY]
+
+    def is_heat(self) -> bool:
+        """Return if mode is Heat."""
+        return self.value in [
+            self.EMERGENCY_HEAT,
+            self.HEATING,
+            self.HEAT_AIR,
+            self.HEAT_COMBINED,
+            self.HEAT_RADIANT,
+        ]
+
+    def is_stop(self) -> bool:
+        """Return if mode is Stop."""
+        return self.value in [self.STOP]
+
+    def is_vent(self) -> bool:
+        """Return if mode is Ventilation."""
+        return self.value in [self.VENTILATION]
+
+
+class TemperatureUnit(int, Enum):
+    """Airzone Cloud temperature units."""
+
+    CELSIUS = 0
+    FAHRENHEIT = 1

aioairzone_cloud/const.py

@@ -0,0 +1,125 @@
+"""Airzone Cloud API constants."""
+
+API_AUTH_LOGIN = "auth/login"
+API_AUTH_REFRESH_TOKEN = "auth/refreshToken"
+API_CELSIUS = "celsius"
+API_CONFIG = "config"
+API_CONNECTION_DATE = "connection_date"
+API_DEVICE_ID = "device_id"
+API_DEVICE_TYPE = "device_type"
+API_DEVICES = "devices"
+API_DISCONNECTION_DATE = "disconnection_date"
+API_ECO_CONF = "eco_conf"
+API_EMAIL = "email"
+API_FAH = "fah"
+API_HUMIDITY = "humidity"
+API_INSTALLATION_ID = "installation_id"
+API_INSTALLATIONS = "installations"
+API_IS_CONNECTED = "isConnected"
+API_LOCAL_TEMP = "local_temp"
+API_MODE = "mode"
+API_MODE_AVAIL = "mode_available"
+API_NAME = "name"
+API_OPTS = "opts"
+API_PARAMS = "params"
+API_PASSWORD = "password"
+API_POWER = "power"
+API_RANGE_SP_MAX_COOL_AIR = "range_sp_cool_air_max"
+API_RANGE_SP_MAX_DRY_AIR = "range_sp_dry_air_max"
+API_RANGE_SP_MAX_EMERHEAT_AIR = "range_sp_emerheat_air_max"
+API_RANGE_SP_MAX_HOT_AIR = "range_sp_hot_air_max"
+API_RANGE_SP_MAX_STOP_AIR = "range_sp_stop_air_max"
+API_RANGE_SP_MAX_VENT_AIR = "range_sp_vent_air_max"
+API_RANGE_SP_MIN_COOL_AIR = "range_sp_cool_air_min"
+API_RANGE_SP_MIN_DRY_AIR = "range_sp_dry_air_min"
+API_RANGE_SP_MIN_EMERHEAT_AIR = "range_sp_emerheat_air_min"
+API_RANGE_SP_MIN_HOT_AIR = "range_sp_hot_air_min"
+API_RANGE_SP_MIN_STOP_AIR = "range_sp_stop_air_min"
+API_RANGE_SP_MIN_VENT_AIR = "range_sp_vent_air_min"
+API_REFRESH_TOKEN = "refreshToken"
+API_SETPOINT = "setpoint"
+API_SLEEP = "sleep"
+API_SP_AIR_COOL = "setpoint_air_cool"
+API_SP_AIR_DRY = "setpoint_air_dry"
+API_SP_AIR_HEAT = "setpoint_air_heat"
+API_SP_AIR_STOP = "setpoint_air_stop"
+API_SP_AIR_VENT = "setpoint_air_vent"
+API_SPEED = "speed"
+API_STAT_AP_MAC = "stat_ap_mac"
+API_STAT_CHANNEL = "stat_channel"
+API_STAT_QUALITY = "stat_quality"
+API_STAT_SSID = "stat_ssid"
+API_STATUS = "status"
+API_STEP = "step"
+API_SYSTEM_NUMBER = "system_number"
+API_TIMER = "timer"
+API_TOKEN = "token"
+API_UNITS = "units"
+API_URL = "https://m.airzonecloud.com"
+API_USER = "user"
+API_USER_LOGOUT = "user/logout"
+API_USER_MODE_CONF = "usermode_conf"
+API_V1 = "api/v1"
+API_WS = "ws"
+API_WS_FW = "ws_fw"
+API_WS_IDS = "ws_ids"
+API_WS_TYPE = "ws_type"
+API_ZONE_NUMBER = "zone_number"
+
+API_AZ_SYSTEM = "az_system"
+API_AZ_ZONE = "az_zone"
+
+API_DEFAULT_TEMP_STEP = 0.5
+
+AZD_CONNECTED = "connected"
+AZD_CONNECTION_DATE = "connection-date"
+AZD_DISCONNECTION_DATE = "disconnection-date"
+AZD_FIRMWARE = "firmware"
+AZD_HUMIDITY = "humidity"
+AZD_ID = "id"
+AZD_INSTALLATION = "installation"
+AZD_INSTALLATIONS = "installations"
+AZD_MASTER = "master"
+AZD_MODE = "mode"
+AZD_MODES = "modes"
+AZD_NAME = "name"
+AZD_POWER = "power"
+AZD_SYSTEM = "system"
+AZD_SYSTEM_ID = "system-id"
+AZD_SYSTEMS = "systems"
+AZD_TEMP = "temperature"
+AZD_TEMP_STEP = "temperature-step"
+AZD_TEMP_SET = "temperature-setpoint"
+AZD_TEMP_SET_COOL_AIR = "temperature-setpoint-cool-air"
+AZD_TEMP_SET_DRY_AIR = "temperature-setpoint-dry-air"
+AZD_TEMP_SET_HOT_AIR = "temperature-setpoint-hot-air"
+AZD_TEMP_SET_STOP_AIR = "temperature-setpoint-stop-air"
+AZD_TEMP_SET_VENT_AIR = "temperature-setpoint-vent-air"
+AZD_TEMP_SET_MAX = "temperature-setpoint-max"
+AZD_TEMP_SET_MAX_COOL_AIR = "temperature-setpoint-max-cool-air"
+AZD_TEMP_SET_MAX_DRY_AIR = "temperature-setpoint-max-dry-air"
+AZD_TEMP_SET_MAX_EMERHEAT_AIR = "temperature-setpoint-max-emerheat-air"
+AZD_TEMP_SET_MAX_HOT_AIR = "temperature-setpoint-max-hot-air"
+AZD_TEMP_SET_MAX_STOP_AIR = "temperature-setpoint-max-stop-air"
+AZD_TEMP_SET_MAX_VENT_AIR = "temperature-setpoint-max-vent-air"
+AZD_TEMP_SET_MIN_COOL_AIR = "temperature-setpoint-min-cool-air"
+AZD_TEMP_SET_MIN_DRY_AIR = "temperature-setpoint-min-dry-air"
+AZD_TEMP_SET_MIN_EMERHEAT_AIR = "temperature-setpoint-min-emerheat-air"
+AZD_TEMP_SET_MIN_HOT_AIR = "temperature-setpoint-min-hot-air"
+AZD_TEMP_SET_MIN_STOP_AIR = "temperature-setpoint-min-stop-air"
+AZD_TEMP_SET_MIN_VENT_AIR = "temperature-setpoint-min-vent-air"
+AZD_TEMP_SET_MIN = "temperature-setpoint-min"
+AZD_TYPE = "type"
+AZD_WEBSERVER = "web-server"
+AZD_WEBSERVERS = "web-servers"
+AZD_WIFI_CHANNEL = "wifi-channel"
+AZD_WIFI_MAC = "wifi-mac"
+AZD_WIFI_QUALITY = "wifi-quality"
+AZD_WIFI_SSID = "wifi-ssid"
+AZD_ZONE = "zone"
+AZD_ZONES = "zones"
+
+HEADER_AUTHORIZATION = "Authorization"
+HEADER_BEARER = "Bearer"
+
+HTTP_CALL_TIMEOUT = 10

aioairzone_cloud/device.py

@@ -0,0 +1,106 @@
+"""Airzone Cloud API Device."""
+from __future__ import annotations
+
+from typing import Any
+
+from .common import OperationMode
+from .const import (
+    API_CONFIG,
+    API_DEVICE_ID,
+    API_IS_CONNECTED,
+    API_MODE,
+    API_MODE_AVAIL,
+    API_SYSTEM_NUMBER,
+    AZD_CONNECTED,
+    AZD_ID,
+    AZD_INSTALLATION,
+    AZD_MODE,
+    AZD_MODES,
+    AZD_NAME,
+    AZD_SYSTEM,
+    AZD_WEBSERVER,
+)
+
+
+class Device:
+    """Airzone Cloud Device."""
+
+    connected: bool
+    name: str
+
+    def __init__(self, inst_id: str, ws_id: str, device_data: dict[str, Any]):
+        """Airzone Cloud Device init."""
+        self.id = str(device_data[API_DEVICE_ID])
+        self.installation_id = inst_id
+        self.mode: OperationMode | None = None
+        self.modes: list[OperationMode] = []
+        self.system_number = int(device_data[API_CONFIG][API_SYSTEM_NUMBER])
+        self.webserver_id = ws_id
+
+        if API_IS_CONNECTED in device_data:
+            self.connected = bool(device_data[API_IS_CONNECTED])
+
+    def data(self) -> dict[str, Any]:
+        """Return Device data."""
+        data = {
+            AZD_CONNECTED: self.get_connected(),
+            AZD_ID: self.get_id(),
+            AZD_INSTALLATION: self.get_installation(),
+            AZD_MODE: self.get_mode(),
+            AZD_NAME: self.get_name(),
+            AZD_SYSTEM: self.get_system(),
+            AZD_WEBSERVER: self.get_webserver(),
+        }
+
+        modes = self.get_modes()
+        if modes:
+            data[AZD_MODES] = modes
+
+        return data
+
+    def get_connected(self) -> bool:
+        """Return connected status."""
+        return self.connected
+
+    def get_id(self) -> str:
+        """Return Device ID."""
+        return self.id
+
+    def get_installation(self) -> str:
+        """Return Installation ID."""
+        return self.installation_id
+
+    def get_mode(self) -> OperationMode | None:
+        """Return Device mode."""
+        return self.mode
+
+    def get_modes(self) -> list[OperationMode] | None:
+        """Return Device modes."""
+        if len(self.modes) > 0:
+            return self.modes
+        return None
+
+    def get_name(self) -> str:
+        """Return Device name."""
+        return self.name
+
+    def get_system(self) -> int:
+        """Return System number."""
+        return self.system_number
+
+    def get_webserver(self) -> str:
+        """Return WebServer ID."""
+        return self.webserver_id
+
+    def update(self, data: dict[str, Any]) -> None:
+        """Update Device data."""
+        if API_IS_CONNECTED in data:
+            self.connected = bool(data[API_IS_CONNECTED])
+
+        if API_MODE in data:
+            self.mode = OperationMode(data[API_MODE])
+        if API_MODE_AVAIL in data and len(data[API_MODE_AVAIL]) > 0:
+            modes = []
+            for mode in data[API_MODE_AVAIL]:
+                modes.append(OperationMode(mode))
+            self.modes = modes

aioairzone_cloud/exceptions.py

@@ -0,0 +1,26 @@
+"""Airzone Cloud API exceptions."""
+from __future__ import annotations
+
+
+class AirzoneCloudError(Exception):
+    """Base class for Airzone Cloud errors."""
+
+
+class APIError(AirzoneCloudError):
+    """Exception raised when API fails."""
+
+
+class LoginError(AirzoneCloudError):
+    """Exception raised when login fails."""
+
+
+class TokenRefreshError(AirzoneCloudError):
+    """Exception raised when token refresh fails."""
+
+
+class InvalidParam(AirzoneCloudError):
+    """Exception raised when invalid param is requested."""
+
+
+class ParamUpdateFailure(AirzoneCloudError):
+    """Exception raised when parameter isn't updated."""