qolsys-controller 0.0.44__py3-none-any.whl → 0.0.87__py3-none-any.whl

qolsys_controller/enum_zwave.py

@@ -1,37 +1,211 @@
-from enum import Enum
-
-
-class ThermostatMode(Enum):
-    OFF: 0x0001
-    HEAT: 0x0002
-    COOL: 0x0004
-    AUTO: 0x0008
-    AUX_HEAT: 0x0010
-    RESUME: 0x0020
-    FAN_ONLY: 0x0040
-    FURNACE: 0x0080
-    DRY_AIR: 0x0100
-    MOIST_AIR: 0x0200
-    AUTO_CHANGEOVER: 0x0400
-    ENERGY_SAVE_HEAT: 0x0800
-    ENERGY_SAVE_COOL: 0x1000
-    AWAY: 0x2000
-    FULL_POWER: 0x4000
-    MANUFACTURER_SPECEFIC: 0x8000
-
-
-class ThermostatFanMode(Enum):
-    AUTO_LOW: 0x0001
-    LOW: 0x0002
-    AUTO_HIGH: 0x0004
-    HIGH: 0x0008
-    AUTO_MEDIUM: 0x0010
-    MEDIUM: 0x0020
-    CIRCULATION: 0x4000
-    HUMIDITY_CIRCULATION: 0x0080
-    LEFT_RIGHT: 0x0100
-    UP_DOWN: 0x0200
-    QUIET: 0x0400
-    EXTERNAL_CIRCULATION: 0x0800
-    MANUFACTURER_SPECEFIC: 0x1000
+from enum import Enum, IntEnum
 
+
+class MeterType(IntEnum):
+    UNKNOWN = 0x00
+    ELECTRIC_METER = 0x01
+    GAZ_METER = 0x02
+    WATER_METER = 0x03
+    HEATING = 0x04
+    COOLING = 0x05
+    RESERVED = 0x6
+
+
+class MeterRateType(IntEnum):
+    UNSPECIFIED = 0x00
+    IMPORT = 0x01
+    EXPORT = 0x02
+    RESERVED = 0x03
+
+
+class ZWaveMultilevelSensorScale(Enum):
+    TEMPERATURE_CELSIUS = "temperature_celsius"
+    TEMPERATURE_FAHRENHEIT = "temperature_fahrenheit"
+    RELATIVE_HUMIDITY = "relative_humidity"
+    WIND_DIRECTION = "wind_direction"
+    BAROMETRIC_PRESSURE = "barometric_pressure"
+    DEW_POINT = "dew_point"
+    RAIN_RATE = "rain_rate"
+    TIDE_LEVEL = "tide_level"
+    WEIGHT = "weight"
+    VOLTS = "volts"
+    AMPS = "amps"
+    WATTS = "watts"
+    DISTANCE = "distance"
+    ANGLE_POSITION = "angle_position"
+    ROTATION = "rotation"
+    WATER_TEMPERATURE_CELSIUS = "water_temperature_celsius"
+    WATER_TEMPERATURE_FAHRENHEIT = "water_temperature_fahrenheit"
+    LUMINOSITY_LUX = "luminosity_lux"
+    UNKNOWN = "unknown"
+
+
+class ZWaveUnknownMeterScale(IntEnum):
+    UNKNOWN = 0
+
+
+class ZWaveElectricMeterScale(IntEnum):
+    KWH = 0
+    KVAH = 1
+    WATTS = 2
+    PULSE_COUNT = 3
+    VOLTS = 4
+    AMPS = 5
+    POWER_FACTOR = 6
+    KVAR = 7
+    KVARH = 8
+
+
+class ZWaveGasMeterScale(IntEnum):
+    CUBIC_METERS = 0
+    CUBIC_FEET = 1
+    PULSE_COUNT = 3
+
+
+class ZWaveWaterMeterScale(IntEnum):
+    CUBIC_METERS = 0
+    CUBIC_FEET = 1
+    US_GALLONS = 2
+    PULSE_COUNT = 3
+
+
+class ZWaveThermalMeterScale(IntEnum):
+    KWH = 0
+    PULSE_COUNT = 3
+
+
+class ThermostatMode(IntEnum):
+    OFF = 0x00
+    HEAT = 0x01
+    COOL = 0x02
+    AUTO = 0x03
+    AUX_HEAT = 0x04
+    RESUME = 0x05
+    FAN_ONLY = 0x06
+    FURNACE = 0x07
+    DRY_AIR = 0x08
+    MOIST_AIR = 0x09
+    AUTO_CHANGEOVER = 0x0A
+    ENERGY_SAVE_HEAT = 0x0B
+    ENERGY_SAVE_COOL = 0x0C
+    AWAY = 0x0F
+
+
+BITMASK_SUPPORTED_THERMOSTAT_MODE = {
+    0: ThermostatMode.OFF,
+    1: ThermostatMode.HEAT,
+    2: ThermostatMode.COOL,
+    3: ThermostatMode.AUTO,
+    4: ThermostatMode.AUX_HEAT,
+    5: ThermostatMode.RESUME,
+    6: ThermostatMode.FAN_ONLY,
+    7: ThermostatMode.FURNACE,
+}
+
+
+class ThermostatSetpointMode(IntEnum):
+    HEATING = 0x01
+    COOLING = 0x02
+    FURNACE = 0x03
+    DRY_AIR = 0x04
+    MOIST_AIR = 0x05
+    AUTO_CHANGEOVER = 0x06
+    ECO_HEATING = 0x07
+    ECO_COOLING = 0x08
+    AWAY_HEATING = 0x09
+    AWAY_COOLING = 0x10
+
+
+BITMASK_SUPPORTED_THERMOSTAT_SETPOINT_MODE = {
+    0: ThermostatSetpointMode.HEATING,
+    1: ThermostatSetpointMode.COOLING,
+    2: ThermostatSetpointMode.FURNACE,
+    3: ThermostatSetpointMode.DRY_AIR,
+    4: ThermostatSetpointMode.MOIST_AIR,
+    5: ThermostatSetpointMode.AUTO_CHANGEOVER,
+    6: ThermostatSetpointMode.ECO_HEATING,
+    7: ThermostatSetpointMode.ECO_COOLING,
+    8: ThermostatSetpointMode.AWAY_HEATING,
+    9: ThermostatSetpointMode.AWAY_COOLING,
+}
+
+
+class ThermostatFanMode(IntEnum):
+    AUTO_LOW = 0x00
+    LOW = 0x01
+    AUTO_HIGH = 0x02
+    HIGH = 0x03
+    AUTO_MEDIUM = 0x04
+    MEDIUM = 0x05
+    CIRCULATION = 0x06
+    HUMIDITY_CIRCULATION = 0x07
+    LEFT_RIGHT = 0x08
+    UP_DOWN = 0x09
+    QUIET = 0x0A
+    EXTERNAL_CIRCULATION = 0x0800
+
+
+BITMASK_SUPPORTED_THERMOSTAT_FAN_MODE = {
+    0: ThermostatFanMode.AUTO_LOW,
+    1: ThermostatFanMode.LOW,
+    2: ThermostatFanMode.AUTO_HIGH,
+    3: ThermostatFanMode.HIGH,
+    4: ThermostatFanMode.AUTO_MEDIUM,
+    5: ThermostatFanMode.MEDIUM,
+    6: ThermostatFanMode.CIRCULATION,
+    7: ThermostatFanMode.HUMIDITY_CIRCULATION,
+}
+
+
+class ZwaveCommandClass(IntEnum):
+    SwitchBinary = 0x25
+    SwitchMultilevel = 0x26
+    SensorMultiLevel = 0x31
+    Meter = 0x32
+    ThermostatMode = 0x40
+    ThermostatSetPoint = 0x43
+    ThermostatFanMode = 0x44
+    ThermostatFanState = 0x45
+    DoorLock = 0x62
+    Alarm = 0x71
+
+
+class ZwaveCommand(IntEnum):
+    SET = 0x01
+    GET = 0x02
+
+
+class ZwaveDeviceClass(Enum):
+    Unknown = 0x00
+    GenericController = 0x01
+    StaticController = 0x02
+    AVControlPoint = 0x03
+    Display = 0x04
+    DoorLock = 0x05
+    Thermostat = 0x06
+    SensorBinary = 0x07
+    SensorMultilevel = 0x08
+    Meter = 0x09
+    EntryControl = 0x0A
+    SemiInteroperable = 0x0B
+    Button = 0x0C
+    RepeaterSlave = 0x0F
+    SwitchBinary = 0x10
+    SwitchMultilevel = 0x11
+    RemoteSwitchBinary = 0x12
+    RemoteSwitchMultilevel = 0x13
+    SwitchToggleBinary = 0x14
+    SwitchToggleMultilevel = 0x15
+    ZIPNode = 0x16
+    Ventilation = 0x17
+    WindowCovering = 0x18
+    BarrierOperator = 0x20
+    SensorNotification = 0x21
+    SoundSwitch = 0x22
+    MeterPulse = 0x23
+    ColorSwitch = 0x24
+    ClimateControlSchedule = 0x25
+    RemoteAssociationActivator = 0x26
+    SceneController = 0x27
+    SceneSceneActuatorConfiguration = 0x28
+    SimpleAVControlPoint = 0x30

qolsys_controller/errors.py

@@ -1,37 +1,39 @@
 import logging
+from typing import Any
 
 LOGGER = logging.getLogger(__name__)
 
 
 class QolsysError(Exception):
-
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
 
 
-class QolsysSslError(QolsysError):
+class QolsysUserCodeError(QolsysError):
+    def __init__(self) -> None:
+        super().__init__("QolsysUserCodeError")
+
 
+class QolsysSslError(QolsysError):
     def __init__(self) -> None:
         super().__init__("QolsysSslError")
 
 
 class QolsysMqttError(QolsysError):
-
     def __init__(self) -> None:
         super().__init__("QolsysMqttError")
 
 
 class QolsysSqlError(QolsysError):
-
-    def __init__(self, operation: dict) -> None:
+    def __init__(self, operation: dict[str, Any]) -> None:
         super().__init__("QolsysSqlError")
 
-        table = f"QolsysSqlError - table:{operation.get('table', "")}"
-        query = f"QolsysSqlError - query:{operation.get('query', "")}"
-        columns = f"QolsysSqlError - columns:{operation.get('columns', "")}"
-        content_values = f"QolsysSqlError - content_values:{operation.get('content_value', "")}"
-        selection = f"QolsysSqlError - selection:{operation.get('selection', "")}"
-        selection_argument = f"QolsysSqlError - selection_argument:{operation.get('selection_argument', "")}"
+        table = f"QolsysSqlError - table:{operation.get('table', '')}"
+        query = f"QolsysSqlError - query:{operation.get('query', '')}"
+        columns = f"QolsysSqlError - columns:{operation.get('columns', '')}"
+        content_values = f"QolsysSqlError - content_values:{operation.get('content_value', '')}"
+        selection = f"QolsysSqlError - selection:{operation.get('selection', '')}"
+        selection_argument = f"QolsysSqlError - selection_argument:{operation.get('selection_argument', '')}"
 
         e = f"""\n{table}\n{query}\n{columns}\n{content_values}\n{selection}\n{selection_argument}"""
         LOGGER.exception(e)

qolsys_controller/mdns.py

@@ -5,10 +5,13 @@ from zeroconf.asyncio import AsyncZeroconf
 
 
 class QolsysMDNS:
-
-    def __init__(self, ip: str, port: int) -> None:
-
-        self.azc = AsyncZeroconf()
+    def __init__(self, ip: str, port: int, external_zero_conf: AsyncZeroconf | None = None) -> None:
+        # Add possible external zeroconf instance provided by Home Assistant by example
+        # If no external instance is provided, create our own
+        if external_zero_conf:
+            self.azc = external_zero_conf
+        else:
+            self.azc = AsyncZeroconf()
 
         self.mdns_info = ServiceInfo(
             "_http._tcp.local.",

qolsys_controller/mqtt_command.py

@@ -0,0 +1,125 @@
+import json
+import logging
+import uuid
+from typing import TYPE_CHECKING, Any
+
+from .errors import QolsysMqttError
+
+if TYPE_CHECKING:
+    import aiomqtt
+
+    from .controller import QolsysController
+
+LOGGER = logging.getLogger(__name__)
+
+
+class MQTTCommand:
+    def __init__(
+        self,
+        controller: "QolsysController",
+        eventName: str,
+    ) -> None:
+        self._controller: QolsysController = controller
+        self._client: aiomqtt.Client | None = controller.aiomqtt
+        self._topic: str = "mastermeid"
+        self._eventName: str = eventName
+        self._payload: dict[str, Any] = {}
+        self._requestID = str(uuid.uuid4())
+        self._qos: int = self._controller.settings.mqtt_qos
+        self._responseTopic = "response_" + self._controller.settings.random_mac
+
+        self.append("requestID", self._requestID)
+        self.append("responseTopic", self._responseTopic)
+        self.append("eventName", self._eventName)
+        self.append("remoteMacAddress", self._controller.settings.random_mac)
+
+    def append(self, argument: str, value: str | dict[str, Any] | int | bool | list[dict[str, Any]] | Any) -> None:
+        self._payload[argument] = value
+
+    async def send_command(self) -> dict[str, Any]:
+        if self._client is None:
+            LOGGER.error("MQTT Client not configured")
+            raise QolsysMqttError
+
+        await self._client.publish(topic=self._topic, payload=json.dumps(self._payload), qos=self._qos)
+        return await self._controller.mqtt_command_queue.wait_for_response(self._requestID)
+
+
+class MQTTCommand_IpcCall(MQTTCommand):
+    def __init__(
+        self,
+        controller: "QolsysController",
+        ipc_service_name: str,
+        ipc_interface_name: str,
+        ipc_transaction_id: int,
+    ) -> None:
+        super().__init__(controller, "ipcCall")
+        self.append("ipcServiceName", ipc_service_name)
+        self.append("ipcInterfaceName", ipc_interface_name)
+        self.append("ipcTransactionID", ipc_transaction_id)
+
+    def append_ipc_request(self, ipc_request: list[dict[str, Any]]) -> None:
+        self.append("ipcRequest", ipc_request)
+
+
+class MQTTCommand_Panel(MQTTCommand_IpcCall):
+    def __init__(
+        self,
+        controller: "QolsysController",
+    ) -> None:
+        super().__init__(
+            controller=controller,
+            ipc_service_name="qinternalservice",
+            ipc_interface_name="android.os.IQInternalService",
+            ipc_transaction_id=7,
+        )
+
+
+class MQTTCommand_ZWave(MQTTCommand_IpcCall):
+    def __init__(
+        self,
+        controller: "QolsysController",
+        node_id: str,
+        zwave_command: list[int],
+    ) -> None:
+        super().__init__(
+            controller=controller,
+            ipc_service_name="qzwaveservice",
+            ipc_interface_name="android.os.IQZwaveService",
+            ipc_transaction_id=47,
+        )
+
+        ipc_request: list[dict[str, Any]] = [
+            {
+                # Node ID
+                "dataType": "int",
+                "dataValue": int(node_id),
+            },
+            {
+                # End Point
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                # Z-Wave Payload
+                "dataType": "byteArray",
+                "dataValue": zwave_command,
+            },
+            {
+                # Transmit option ?
+                "dataType": "int",
+                "dataValue": 0,
+            },
+            {
+                # Priority
+                "dataType": "int",
+                "dataValue": 106,
+            },
+            {
+                # Callback ?
+                "dataType": "byteArray",
+                "dataValue": [0],
+            },
+        ]
+
+        self.append_ipc_request(ipc_request)

qolsys_controller/mqtt_command_queue.py

@@ -1,12 +1,13 @@
 import asyncio
+from typing import Any
 
 
 class QolsysMqttCommandQueue:
     def __init__(self) -> None:
         self.lock = asyncio.Lock()
-        self.waiters: dict[str, asyncio.Future] = {}
+        self.waiters: dict[str, asyncio.Future[Any]] = {}
 
-    async def handle_response(self, response: dict) -> None:
+    async def handle_response(self, response: dict[str, str]) -> None:
         requestID = response.get("requestID")
 
         if not requestID:
@@ -19,7 +20,7 @@ class QolsysMqttCommandQueue:
         if future and not future.done():
             future.set_result(response)
 
-    async def wait_for_response(self, request_id: str) -> None:
+    async def wait_for_response(self, request_id: str) -> dict[str, Any]:
         if request_id in self.waiters:
             msg = f"Duplicate waiter for request_id: {request_id}"
             raise ValueError(msg)
@@ -28,4 +29,4 @@ class QolsysMqttCommandQueue:
         async with self.lock:
             self.waiters[request_id] = future
 
-        return await future
+        return await future  # type: ignore[no-any-return]

qolsys_controller/observable.py

@@ -17,12 +17,12 @@ class QolsysObservable:
     def unregister(self, observer: Callable[[], None]) -> None:
         self._observers.remove(observer)
 
-    def notify(self, **payload) -> None:  # noqa: ANN003
+    def notify(self) -> None:
         if self._batch_update_active:
             self._batch_update_change_detected = True
         else:
             for observer in self._observers:
-                observer(self, **payload)
+                observer()
 
     def start_batch_update(self) -> None:
         self._batch_update_change_detected = False