paradox-alarm-interface 3.3.0__tar.gz → 3.4.2.dev0__tar.gz

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: paradox-alarm-interface
-Version: 3.3.0
+Version: 3.4.2.dev0
 Summary: Interface to Paradox Alarm Panels
 Home-page: https://github.com/ParadoxAlarmInterface/pai
 Author: Jevgeni Kiski, João Paulo Barraca
@@ -18,14 +18,14 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.8
+Requires-Python: <3.12,>=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: construct~=2.9.43
 Requires-Dist: argparse>=1.4.0
 Requires-Dist: python-slugify>=4.0.1
 Requires-Dist: pytz>=2021.3
-Requires-Dist: paho_mqtt>=1.5.0
+Requires-Dist: paho_mqtt<2,>=1.5.0
 Requires-Dist: requests>=2.20.0
 Requires-Dist: pyserial-asyncio>=0.4
 Provides-Extra: yaml
@@ -107,8 +107,8 @@ See [wiki](https://github.com/ParadoxAlarmInterface/pai/wiki/Installation)
 ## Tested Environment
 
 Tested in the following environment:
-* Python 3.6, 3.7, 3.8
-* Mosquitto MQTT Broker >v 1.4.8
+* Python 3.6, 3.7, 3.8, 3.9, 3.10, 3.11
+* Mosquitto MQTT Broker > 1.4.8
 * OrangePi 2G-IOT, NanoPi NEO, and Raspberry Pi 3 through their built in Serial Port (with a level shifter!), or a USB RS232 TTL adapter (CP2102, PL2303, CH340, etc..)
 * Ubuntu Server 16.04.3 LTS
 * Paradox MG5050, SP7000 and EVO panels

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/README.md

@@ -65,8 +65,8 @@ See [wiki](https://github.com/ParadoxAlarmInterface/pai/wiki/Installation)
 ## Tested Environment
 
 Tested in the following environment:
-* Python 3.6, 3.7, 3.8
-* Mosquitto MQTT Broker >v 1.4.8
+* Python 3.6, 3.7, 3.8, 3.9, 3.10, 3.11
+* Mosquitto MQTT Broker > 1.4.8
 * OrangePi 2G-IOT, NanoPi NEO, and Raspberry Pi 3 through their built in Serial Port (with a level shifter!), or a USB RS232 TTL adapter (CP2102, PL2303, CH340, etc..)
 * Ubuntu Server 16.04.3 LTS
 * Paradox MG5050, SP7000 and EVO panels

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/__init__.py

@@ -1,3 +1,3 @@
-VERSION = "3.3.0"
+VERSION = "3.4.2-dev"
 
 __version__ = VERSION

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/config.py

@@ -55,6 +55,7 @@ class Config:
         "IP_CONNECTION_BARE": False,  # IP endpoint connects directly to panel. Used for Serial Tunnels over TCP
         # Paradox
         "KEEP_ALIVE_INTERVAL": 10,  # Interval between status updates
+        "IO_TIMEOUT": 0.5,  # Timeout for IO operations
         "LIMITS": {},  # By default all zones will be monitored
         "LABEL_ENCODING": "paradox-en",  # Encoding to use when decoding labels. paradox-* or https://docs.python.org/3/library/codecs.html#standard-encodings
         "LABEL_REFRESH_INTERVAL": (

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/connections/ip/connection.py

@@ -1,17 +1,15 @@
-# -*- coding: utf-8 -*-
-
+from abc import ABC, abstractmethod
 import asyncio
 import logging
-from abc import ABC, abstractmethod
 
 from construct import Container
 
+from paradox.config import config as cfg
 from paradox.connections.connection import Connection
 from paradox.connections.handler import IPConnectionHandler
 from paradox.connections.ip.commands import IPModuleConnectCommand
 from paradox.connections.ip.stun_session import StunSession
-from paradox.connections.protocols import (IPConnectionProtocol,
-                                           SerialConnectionProtocol)
+from paradox.connections.protocols import IPConnectionProtocol, SerialConnectionProtocol
 from paradox.exceptions import PAICriticalException
 from paradox.lib.handlers import FutureHandler, HandlerRegistry
 
@@ -94,7 +92,7 @@ class IPConnectionWithEncryption(MultiAttemptConnection, IPConnectionHandler, AB
     def on_ip_message(self, container: Container):
         return self.loop.create_task(self.ip_handler_registry.handle(container))
 
-    async def wait_for_ip_message(self, timeout=2) -> Container:
+    async def wait_for_ip_message(self, timeout=cfg.IO_TIMEOUT) -> Container:
         future = FutureHandler()
         return await self.ip_handler_registry.wait_until_complete(future, timeout)
 
@@ -107,7 +105,10 @@ class IPConnectionWithEncryption(MultiAttemptConnection, IPConnectionHandler, AB
 
 class LocalIPConnection(IPConnectionWithEncryption):
     def __init__(
-        self, host, port, password,
+        self,
+        host,
+        port,
+        password,
     ):
         super().__init__(password)
         self.host = host

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/connections/protocols.py

@@ -1,12 +1,16 @@
+from abc import abstractmethod
 import asyncio
 import binascii
 import logging
-from abc import abstractmethod
 
 from paradox.config import config as cfg
 from paradox.connections.handler import ConnectionHandler, IPConnectionHandler
-from paradox.connections.ip.parsers import (IPMessageCommand, IPMessageRequest,
-                                            IPMessageResponse, IPMessageType)
+from paradox.connections.ip.parsers import (
+    IPMessageCommand,
+    IPMessageRequest,
+    IPMessageResponse,
+    IPMessageType,
+)
 
 logger = logging.getLogger("PAI").getChild(__name__)
 
@@ -52,11 +56,11 @@ class ConnectionProtocol(asyncio.Protocol):
         if self.transport:
             try:
                 self.transport.close()
-            except:
+            except Exception:
                 logger.exception("Connection transport close raised Exception")
             self.transport = None
 
-        await asyncio.wait_for(self._closed, timeout=1)
+        await asyncio.wait_for(self._closed, timeout=cfg.IO_TIMEOUT)
 
     @abstractmethod
     def send_message(self, message):
@@ -94,7 +98,7 @@ class ConnectionProtocol(asyncio.Protocol):
 class SerialConnectionProtocol(ConnectionProtocol):
     def send_message(self, message):
         if cfg.LOGGING_DUMP_PACKETS:
-            logger.debug("PAI -> SER {}".format(binascii.hexlify(message)))
+            logger.debug(f"PAI -> SER {binascii.hexlify(message)}")
 
         self.check_active()
 
@@ -137,7 +141,7 @@ class SerialConnectionProtocol(ConnectionProtocol):
             if checksum(frame, min_length):
                 self.buffer = self.buffer[len(frame) :]  # Remove message
                 if cfg.LOGGING_DUMP_PACKETS:
-                    logger.debug("SER -> PAI {}".format(binascii.hexlify(frame)))
+                    logger.debug(f"SER -> PAI {binascii.hexlify(frame)}")
 
                 self.handler.on_message(frame)
             else:
@@ -146,14 +150,14 @@ class SerialConnectionProtocol(ConnectionProtocol):
 
 class IPConnectionProtocol(ConnectionProtocol):
     def __init__(self, handler: IPConnectionHandler, key):
-        super(IPConnectionProtocol, self).__init__(handler)
+        super().__init__(handler)
 
         self.handler = handler
         self.key = key
 
     def send_raw(self, raw):
         if cfg.LOGGING_DUMP_PACKETS:
-            logger.debug("PAI -> IP (raw) {}".format(binascii.hexlify(raw)))
+            logger.debug(f"PAI -> IP (raw) {binascii.hexlify(raw)}")
 
         self.check_active()
 
@@ -161,7 +165,7 @@ class IPConnectionProtocol(ConnectionProtocol):
 
     def send_message(self, message):
         if cfg.LOGGING_DUMP_PACKETS:
-            logger.debug("PAI -> IP (payload) {}".format(binascii.hexlify(message)))
+            logger.debug(f"PAI -> IP (payload) {binascii.hexlify(message)}")
 
         self.check_active()
 
@@ -180,7 +184,7 @@ class IPConnectionProtocol(ConnectionProtocol):
             password=self.key,
         )
         if cfg.LOGGING_DUMP_PACKETS:
-            logger.debug("PAI -> IP (raw) {}".format(binascii.hexlify(msg)))
+            logger.debug(f"PAI -> IP (raw) {binascii.hexlify(msg)}")
 
         self.transport.write(msg)
 
@@ -188,9 +192,7 @@ class IPConnectionProtocol(ConnectionProtocol):
         message = IPMessageResponse.parse(data, password=self.key)
 
         if cfg.LOGGING_DUMP_PACKETS:
-            logger.debug(
-                "IP -> PAI (payload) {}".format(binascii.hexlify(message.payload))
-            )
+            logger.debug(f"IP -> PAI (payload) {binascii.hexlify(message.payload)}")
 
         if message.header.message_type == IPMessageType.serial_passthrough_response:
             self.handler.on_message(message.payload)
@@ -218,7 +220,7 @@ class IPConnectionProtocol(ConnectionProtocol):
             return
 
         if cfg.LOGGING_DUMP_PACKETS:
-            logger.debug("IP -> PAI (raw) {}".format(binascii.hexlify(self.buffer)))
+            logger.debug(f"IP -> PAI (raw) {binascii.hexlify(self.buffer)}")
 
         self._process_message(self.buffer)
         self.buffer = b""

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/console_scripts/ip150_connection_decrypt.py

@@ -1,27 +1,32 @@
 #!/usr/bin/env python3
 import argparse
 import binascii
-import traceback
 from collections import OrderedDict
+import re
+import traceback
 
 import yaml
 
-from paradox.connections.ip.parsers import (IPMessageCommand, IPMessageRequest,
-                                            IPMessageResponse, IPMessageType,
-                                            IPPayloadConnectResponse)
+from paradox.connections.ip.parsers import (
+    IPMessageCommand,
+    IPMessageRequest,
+    IPMessageResponse,
+    IPMessageType,
+    IPPayloadConnectResponse,
+)
 from paradox.hardware import create_panel
 from paradox.hardware.parsers import InitiateCommunicationResponse
 
 
-class Colors: # You may need to change color settings
-    RED = '\033[31m'
-    ENDC = '\033[m'
-    GREEN = '\033[32m'
-    YELLOW = '\033[33m'
-    BLUE = '\033[34m'
-    MAGENTA = '\033[95m'
-    CYAN = '\033[96m'
-    ON_WHITE = '\033[47m'
+class Colors:  # You may need to change color settings
+    RED = "\033[31m"
+    ENDC = "\033[m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[95m"
+    CYAN = "\033[96m"
+    ON_WHITE = "\033[30m\033[47m"
 
 
 def ordered_load(stream, Loader=yaml.loader.SafeLoader, object_pairs_hook=OrderedDict):
@@ -54,14 +59,22 @@ class PayloadParser:
             elif message_type == IPMessageType.ip_response:
                 self._parse_ip_response(parsed)
         except Exception:
+            print(f"{Colors.RED}Failed to parse message: \n{parsed}{Colors.ENDC}")
             traceback.print_exc()
 
     def _parse_ip_response(self, parsed):
-        if parsed.header.command == IPMessageCommand.connect and parsed.header.sub_command == 0:
-            print(f"{Colors.ON_WHITE}{IPPayloadConnectResponse.parse(parsed.payload)}{Colors.ENDC}")
+        if (
+            parsed.header.command == IPMessageCommand.connect
+            and parsed.header.sub_command == 0
+        ):
+            print(
+                f"{Colors.ON_WHITE}{IPPayloadConnectResponse.parse(parsed.payload)}{Colors.ENDC}"
+            )
             if len(parsed.payload) > 25:
                 p = parsed.payload[25:62]
-                print(f"{Colors.ON_WHITE}InitiateCommunicationResponse:\n{InitiateCommunicationResponse.parse(p)}{Colors.ENDC}")
+                print(
+                    f"{Colors.ON_WHITE}InitiateCommunicationResponse:\n{InitiateCommunicationResponse.parse(p)}{Colors.ENDC}"
+                )
         elif parsed.header.command == IPMessageCommand.multicommand:
             self._parse_multicommand(parsed, "frompanel")
         else:
@@ -74,7 +87,7 @@ class PayloadParser:
             self._parse_generic_multicommand(parsed, direction)
         elif parsed.header.sub_command == 0x1:  # MGSP multiread
             self._parse_generic_mgsp_multiread(parsed, direction)
-        elif parsed.header.sub_command == 0xdd:  # Unified multiread
+        elif parsed.header.sub_command == 0xDD:  # Unified multiread
             pass
 
     def _parse_serial_passthrough_response(self, parsed):
@@ -95,7 +108,9 @@ class PayloadParser:
             ram_address = parsed_payload.fields.value.address
             ram_parser = self.panel.get_message("RAMDataParserMap").get(ram_address)
             if ram_parser is not None:
-                print(f"{Colors.ON_WHITE}{ram_parser.parse(parsed_payload.fields.value.data)}{Colors.ENDC}")
+                print(
+                    f"{Colors.ON_WHITE}{ram_parser.parse(parsed_payload.fields.value.data)}{Colors.ENDC}"
+                )
             else:
                 print(
                     f"{Colors.RED}No parser for {ram_address} ram address, data: {binascii.hexlify(parsed_payload.fields.value.data)}{Colors.ENDC}"
@@ -105,14 +120,16 @@ class PayloadParser:
         if parsed.header.command == IPMessageCommand.multicommand:
             self._parse_multicommand(parsed, "topanel")
         else:
-            print(f"{Colors.RED}No parser for ip_request payload: {binascii.hexlify(parsed.payload)}{Colors.ENDC}")
+            print(
+                f"{Colors.RED}No parser for ip_request payload: {binascii.hexlify(parsed.payload)}{Colors.ENDC}"
+            )
 
     def _parse_generic_multicommand(self, parsed, direction: str):
         i = 0
         while i < len(parsed.payload):
             cmd_len = parsed.payload[i]
             i += 1
-            cmd = parsed.payload[i:i + cmd_len]
+            cmd = parsed.payload[i : i + cmd_len]
             assert len(cmd) == cmd_len
             i += cmd_len
             print(f"{Colors.ON_WHITE}Multicommand: {cmd}{Colors.ENDC}")
@@ -130,9 +147,20 @@ class PayloadParser:
         return parsed_payload
 
     def _parse_generic_mgsp_multiread(self, parsed, direction):
-        print(
-            f"{Colors.RED}No parser for {direction} mgsp_multiread{Colors.ENDC}"
-        )
+        print(f"{Colors.RED}No parser for {direction} mgsp_multiread{Colors.ENDC}")
+
+
+def old_yaml_format_traverser(data):
+    re_key = re.compile(r"peer(\d+)_(\d+)")
+    for key, value in data.items():
+        # example peer0_0, where 0 is peer number and 0 is index number
+        matches = re_key.match(key)
+
+        yield {
+            "peer": int(matches.group(1)),
+            "data": value,
+            "index": int(matches.group(2)),
+        }
 
 
 def decrypt_file(file, password, max_packets: int = None):
@@ -140,9 +168,16 @@ def decrypt_file(file, password, max_packets: int = None):
         data = ordered_load(file, yaml.loader.SafeLoader)
         parser = PayloadParser()
 
+        if "peers" in data and "packets" in data:
+            iterator = data["packets"]
+        else:
+            iterator = old_yaml_format_traverser(data)
+
         n = 0
-        for key, value in data.items():
-            if not value[0] == 0xaa:
+        for packet in iterator:
+            value = packet["data"]
+            key = packet["index"]
+            if not value[0] == 0xAA:
                 print(f"{Colors.RED}Not an IP packet: {value}{Colors.ENDC}")
                 continue
             header = value[0:16]
@@ -167,7 +202,6 @@ def decrypt_file(file, password, max_packets: int = None):
                 if parsed.header.sub_command == 0:
                     assert password == parsed.payload, "Wrong decryption password"
 
-
             if (
                 parsed.header.command == IPMessageCommand.connect
                 and parsed.header.message_type == IPMessageType.ip_response
@@ -187,7 +221,7 @@ def decrypt_file(file, password, max_packets: int = None):
 
             print(
                 f"\tpayload: {binascii.hexlify(parsed.payload)}\n",
-                f"\tpayload_raw: {parsed.payload}"
+                f"\tpayload_raw: {parsed.payload}",
             )
 
             print(parsed)

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/hardware/__init__.py

@@ -30,6 +30,7 @@ def create_panel(core, start_communication_response: Container = None) -> Panel:
     elif product_id in [
         "SPECTRA_SP4000",
         "SPECTRA_SP5500",
+        "SPECTRA_SP550_PLUS",
         "SPECTRA_SP6000",
         "SPECTRA_SP7000",
         "SPECTRA_SP65",

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/hardware/common.py

@@ -44,6 +44,7 @@ ProductIdEnum = Enum(
     SPECTRA_SP7000=23,
     SPECTRA_SP4000=26,
     SPECTRA_SP65=27,
+    SPECTRA_SP550_PLUS=28,
     SPECTRA_SP6000_PLUS=29,
     SPECTRA_SP7000_PLUS=30,
     MAGELLAN_MG5000=64,

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/hardware/evo/panel.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 import binascii
 import inspect
 import logging
@@ -10,17 +8,26 @@ from construct import ChecksumError, Construct, Container, MappingError
 from paradox.config import config as cfg
 from paradox.exceptions import AuthenticationFailed, StatusRequestException
 
-from ..panel import Panel as PanelBase
 from . import parsers
+from ..panel import Panel as PanelBase
 from .event import event_map
 from .property import property_map
 
 logger = logging.getLogger("PAI").getChild(__name__)
 
 ZONE_ACTIONS = dict(
-    bypass={"flags": {"bypassed": True}, "operation": "set",},
-    clear_bypass={"flags": {"bypassed": True}, "operation": "clear",},
-    clear_alarm_memory={"flags": {"generated_alarm": True}, "operation": "clear",},
+    bypass={
+        "flags": {"bypassed": True},
+        "operation": "set",
+    },
+    clear_bypass={
+        "flags": {"bypassed": True},
+        "operation": "clear",
+    },
+    clear_alarm_memory={
+        "flags": {"generated_alarm": True},
+        "operation": "clear",
+    },
 )
 
 
@@ -33,14 +40,14 @@ class Panel_EVOBase(PanelBase):
     def __init__(
         self, core, start_communication_response, variable_message_length=True
     ):
-        super(Panel_EVOBase, self).__init__(core, variable_message_length)
+        super().__init__(core, variable_message_length)
 
         self._populate_settings(start_communication_response)
 
     def _populate_settings(self, start_communication_response):
         raw_data = (
-                start_communication_response.fields.data
-                + start_communication_response.checksum
+            start_communication_response.fields.data
+            + start_communication_response.checksum
         )
         parsed = parsers.InitializeCommunication.parse(raw_data)
         if cfg.LOGGING_DUMP_MESSAGES:
@@ -55,7 +62,7 @@ class Panel_EVOBase(PanelBase):
         except ResourceWarning:
             pass
 
-        return super(Panel_EVOBase, self).get_message(name)
+        return super().get_message(name)
 
     async def dump_memory(self, file, memory_type):
         """
@@ -73,6 +80,12 @@ class Panel_EVOBase(PanelBase):
         mem_type = "RAM" if ram else "EEPROM"
         logger.info("Dump " + mem_type)
 
+        def expect(command, address):
+            return (
+                lambda m: m.fields.value.po.command == command
+                and m.fields.value.address == address
+            )
+
         packet_length = 64  # 64 is max
         for address in range_:
             args = dict(
@@ -82,8 +95,7 @@ class Panel_EVOBase(PanelBase):
             reply = await self.core.send_wait(
                 parsers.ReadEEPROM,
                 args,
-                reply_expected=lambda m: m.fields.value.po.command == 0x5
-                and m.fields.value.address == address,
+                reply_expected=expect(0x5, address),
             )
 
             if reply is None:
@@ -101,7 +113,7 @@ class Panel_EVOBase(PanelBase):
             if message is None or len(message) == 0:
                 return None
 
-            parent_parsed = super(Panel_EVOBase, self).parse_message(message, direction)
+            parent_parsed = super().parse_message(message, direction)
             if parent_parsed:
                 return parent_parsed
 
@@ -147,13 +159,9 @@ class Panel_EVOBase(PanelBase):
                         return parsers.RequestedEvent.parse(message)
 
         except ChecksumError as e:
-            logger.error(
-                "ChecksumError %s, message: %s" % (str(e), binascii.hexlify(message))
-            )
-        except:
-            logger.exception(
-                "Exception parsing message: %s" % (binascii.hexlify(message))
-            )
+            logger.error("ChecksumError %s, message: %s", e, binascii.hexlify(message))
+        except Exception:
+            logger.exception("Exception parsing message: %s", binascii.hexlify(message))
 
         return None
 
@@ -179,13 +187,17 @@ class Panel_EVOBase(PanelBase):
                 "(Babyware) Tab."
             )
             raise AuthenticationFailed("Wrong PASSWORD")
-        else:  # command == 0x1
-            if reply.fields.value.po.status.Winload_connected:
-                logger.info("Authentication Success")
-                return True
-            else:
-                logger.error("Authentication Failed")
-                return False
+
+        if reply.fields.value.po.command == 0x1:
+            logger.info("Authentication Success")
+
+            if not reply.fields.value.po.status.Winload_connected:
+                logger.warning("Winload_connected is still False")
+
+            return True
+
+        logger.error("Invalid response to InitializeCommunication: %s", reply)
+        return False
 
     @staticmethod
     def _request_status_reply_check(message: Container, address: int):
@@ -223,7 +235,7 @@ class Panel_EVOBase(PanelBase):
         :param str command: textual command
         :return: True if we have at least one success
         """
-        args = dict(partitions=dict((i, command) for i in partitions))
+        args = dict(partitions={i: command for i in partitions})
 
         try:
             reply = await self.core.send_wait(

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/hardware/spectra_magellan/adapters.py

@@ -1,9 +1,8 @@
-# -*- coding: utf-8 -*-
-
 import datetime
+from enum import Enum
 
 from construct import Adapter
-from enum import Enum
+
 
 class DateAdapter(Adapter):
     def _decode(self, obj, context, path):
@@ -35,7 +34,6 @@ class PartitionStateAdapter(Adapter):
     states = dict(arm=4, disarm=5, arm_sleep=3, arm_stay=1, none=0)
 
     def _decode(self, obj, context, path):
-
         for k, v in enumerate(self.states):
             if v == obj[0]:
                 return k
@@ -53,7 +51,6 @@ class ZoneStateAdapter(Adapter):
     states = dict(bypass=0x10)
 
     def _decode(self, obj, context, path):
-
         for k, v in enumerate(self.states):
             if v == obj[0]:
                 return k
@@ -227,16 +224,24 @@ class PGMDefinitionAdapter(Adapter):
         disabled = sum(obj) == 0
 
         if disabled:
-            return 'disabled'
+            return "disabled"
 
         try:
-            activation_event = PGMDefinitionAdapter.PGMEvent(obj[0]) if sum(obj[:3]) != 0 else 'disabled'
-        except:
-            activation_event = 'unknown'
+            activation_event = (
+                PGMDefinitionAdapter.PGMEvent(obj[0])
+                if sum(obj[:3]) != 0
+                else "disabled"
+            )
+        except Exception:
+            activation_event = "unknown"
 
         try:
-            deactivation_event = PGMDefinitionAdapter.PGMEvent(obj[3]) if sum(obj[3:]) != 0 else 'disabled'
-        except:
-            deactivation_event = 'unknown'
+            deactivation_event = (
+                PGMDefinitionAdapter.PGMEvent(obj[3])
+                if sum(obj[3:]) != 0
+                else "disabled"
+            )
+        except Exception:
+            deactivation_event = "unknown"
 
         return dict(activation=activation_event, deactivation=deactivation_event)

{paradox-alarm-interface-3.3.0 → paradox_alarm_interface-3.4.2.dev0}/paradox/interfaces/ip_interface/interface.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 # IP Interface
 
 import asyncio
@@ -46,16 +44,14 @@ class IPInterface(Interface):
     async def run(self):
         try:
             self.server = await asyncio.start_server(
-                self.handle_client, self.addr, self.port, loop=self.alarm.work_loop
+                self.handle_client, self.addr, self.port
             )
             logger.info(
-                "IP Interface: serving on {}".format(
-                    self.server.sockets[0].getsockname()
-                )
+                "IP Interface: serving on %s", self.server.sockets[0].getsockname()
             )
             logger.info("IP Interface started")
         except Exception as e:
-            logger.error("Failed to start IP Interface {}".format(e))
+            logger.error("Failed to start IP Interface: %s", e)
 
     async def handle_client(self, reader, writer):
         """
@@ -67,10 +63,10 @@ class IPInterface(Interface):
         """
 
         self.client_nr = (self.client_nr + 1) % 256
-        logger.info("Client %d connected" % self.client_nr)
+        logger.info("Client %d connected", self.client_nr)
 
         connection = ClientConnection(reader, writer, self.alarm, self.key)
-        handler_name = "%s_%d" % (self.name, self.client_nr)
+        handler_name = f"{self.name}_{self.client_nr}"
         self.alarm.connection.register_raw_handler(
             PersistentHandler(connection.handle_panel_raw_message, name=handler_name)
         )
@@ -79,10 +75,10 @@ class IPInterface(Interface):
 
         try:
             await connection.handle()
-        except:
-            logger.exception("Client %d connection raised exception" % self.client_nr)
+        except Exception:
+            logger.exception("Client %d connection raised exception", self.client_nr)
         finally:
             self.alarm.connection.deregister_raw_handler(handler_name)
 
             asyncio.get_event_loop().create_task(self.alarm.resume())
-            logger.info("Client %d disconnected" % self.client_nr)
+            logger.info("Client %d disconnected", self.client_nr)