Fixes for newer python versions.

Author: yozik04

paradox/connections/protocols.py

@@ -37,16 +37,21 @@ def __init__(self, handler: ConnectionHandler):
 
         self.handler = handler
 
-        self._closed = asyncio.get_event_loop().create_future()
+        self._closed: asyncio.Future = None  # type: ignore[assignment]
         self.buffer = b""
 
     def connection_made(self, transport):
+        self._closed = asyncio.get_running_loop().create_future()
         self.transport = transport
 
         self.handler.on_connection()
 
     def is_active(self) -> bool:
-        return bool(self.transport) and not self._closed.done()
+        return (
+            bool(self.transport)
+            and self._closed is not None
+            and not self._closed.done()
+        )
 
     def check_active(self):
         if not self.is_active():
@@ -60,7 +65,8 @@ async def close(self):
                 logger.exception("Connection transport close raised Exception")
             self.transport = None
 
-        await asyncio.wait_for(self._closed, timeout=cfg.IO_TIMEOUT)
+        if self._closed is not None:
+            await asyncio.wait_for(self._closed, timeout=cfg.IO_TIMEOUT)
 
     @abstractmethod
     def send_message(self, message):
@@ -71,7 +77,7 @@ def connection_lost(self, exc):
         self.buffer = b""
         self.transport = None
 
-        if not self._closed.done():
+        if self._closed is not None and not self._closed.done():
             if exc is None:
                 self._closed.set_result(None)
             else:
@@ -91,7 +97,7 @@ def __del__(self):
         # Prevent reports about unhandled exceptions.
         # Better than self._closed._log_traceback = False hack
         closed = self._closed
-        if closed.done() and not closed.cancelled():
+        if closed is not None and closed.done() and not closed.cancelled():
             closed.exception()
 
 

paradox/data/memory_storage.py

@@ -1,5 +1,5 @@
-import logging
 from collections import defaultdict
+import logging
 from typing import Callable
 
 from paradox.config import config as cfg
@@ -57,7 +57,7 @@ def update_container_object(self, container_name: str, key: str, changes: dict):
             ):  # function to make new value from the old one
                 try:
                     property_value = property_value(old)
-                except:
+                except Exception:
                     logger.exception(
                         'Exception caught during property "%s" convert. Ignoring',
                         property_name,

paradox/event.py

@@ -1,10 +1,10 @@
+from collections import namedtuple
+from copy import copy
 import datetime
+from enum import Enum
 import logging
 import time
 import typing
-from collections import namedtuple
-from copy import copy
-from enum import Enum
 
 from construct import Container
 
@@ -70,7 +70,7 @@ def __init__(self, label_provider=None):
         if label_provider is not None:
             self.label_provider = label_provider
         else:
-            self.label_provider = lambda type, value: "[{}:{}]".format(type, value)
+            self.label_provider = lambda type, value: f"[{type}:{value}]"
 
     def __repr__(self):
         lvars = {}
@@ -81,11 +81,7 @@ def __repr__(self):
             str(self.__class__)
             + "\n"
             + "\n".join(
-                (
-                    "{} = {}".format(item, lvars[item])
-                    for item in lvars
-                    if not item.startswith("_")
-                )
+                f"{item} = {lvars[item]}" for item in lvars if not item.startswith("_")
             )
         )
 
@@ -126,7 +122,7 @@ def call_hook(self, *args, **kwargs):
             kwargs["event"] = self
             try:
                 self.hook_fn(*args, **kwargs)
-            except:
+            except Exception:
                 logger.exception("Failed to call event hook")
 
 
@@ -138,9 +134,9 @@ def __init__(self, event: Container, event_map: dict, label_provider=None):
 
         # parse event map
         if raw.event.major not in event_map:
-            raise AssertionError("Unknown event major: {}".format(raw))
+            raise AssertionError(f"Unknown event major: {raw}")
 
-        super(LiveEvent, self).__init__(label_provider=label_provider)
+        super().__init__(label_provider=label_provider)
 
         self.major = raw.event.major  # Event major code
         self.minor = raw.event.minor  # Event minor code
@@ -177,9 +173,7 @@ def __init__(self, event: Container, event_map: dict, label_provider=None):
                 for k in sub:
                     if k == "message":
                         event_map[k] = (
-                            "{}: {}".format(event_map[k], sub[k])
-                            if k in event_map
-                            else sub[k]
+                            f"{event_map[k]}: {sub[k]}" if k in event_map else sub[k]
                         )
                     elif isinstance(sub[k], typing.List):  # for tags or other lists
                         event_map[k] = event_map.get(k, []) + sub[k]

paradox/hardware/panel.py

@@ -1,19 +1,19 @@
-import binascii
-import inspect
-import logging
-import typing
 from abc import abstractmethod
+import binascii
 from collections import defaultdict, namedtuple
+import inspect
 from itertools import chain
+import logging
 from time import time
+import typing
 
 from construct import Construct, Container, EnumIntegerString
 
 from paradox.config import config as cfg, get_limits_for_type
 from paradox.lib.utils import construct_free, sanitize_key
 
-from ..lib import ps
 from . import parsers
+from ..lib import ps
 
 logger = logging.getLogger("PAI").getChild(__name__)
 
@@ -54,7 +54,7 @@ def get_message(self, name) -> Construct:
         if name in clsmembers:
             return clsmembers[name]
         else:
-            raise ResourceWarning("{} parser not found".format(name))
+            raise ResourceWarning(f"{name} parser not found")
 
     @staticmethod
     def get_error_message(error_code) -> str:
@@ -170,7 +170,9 @@ async def load_definitions(self):
                         if definition != "disabled":
                             enabled_indexes.add(index)
 
-                cfg.LIMITS[elem_type] = get_limits_for_type(elem_type, list(enabled_indexes))
+                cfg.LIMITS[elem_type] = get_limits_for_type(
+                    elem_type, list(enabled_indexes)
+                )
                 cfg.LIMITS[elem_type] = list(
                     set(cfg.LIMITS[elem_type]).intersection(enabled_indexes)
                 )
@@ -339,10 +341,8 @@ def handle_status(message: Container, parser_map):
             if cfg.LOGGING_DUMP_MESSAGES:
                 logger.debug(f"Status parsed({mvars.address}): {res}")
             return res
-        except:
-            logger.exception(
-                "Unable to parse RAM Status Block ({})".format(mvars.address)
-            )
+        except Exception:
+            logger.exception(f"Unable to parse RAM Status Block ({mvars.address})")
             return
 
     @abstractmethod

paradox/hardware/spectra_magellan/panel.py

@@ -1,5 +1,3 @@
-# -*- coding: utf-8 -*-
-
 import asyncio
 import binascii
 import inspect
@@ -10,10 +8,11 @@
 
 from paradox.config import config as cfg
 from paradox.exceptions import AuthenticationFailed, StatusRequestException
+
 from . import parsers
+from ..panel import Panel as PanelBase
 from .event import event_map
 from .property import property_map
-from ..panel import Panel as PanelBase
 
 logger = logging.getLogger("PAI").getChild(__name__)
 
@@ -43,7 +42,8 @@ class Panel(PanelBase):
         "status_base2": 0x1FE0,
         "definitions": {
             "zone": {"addresses": [range(0x730, 0x7A0, 0x03)]},
-            "pgm": {"addresses": [range(0x7A0, 0x800, 0x06)]}},
+            "pgm": {"addresses": [range(0x7A0, 0x800, 0x06)]},
+        },
         "labels": {
             "zone": {"label_offset": 0, "addresses": [range(0x010, 0x210, 0x10)]},
             "pgm": {
@@ -64,7 +64,7 @@ class Panel(PanelBase):
     def __init__(
         self, core, start_communication_response, variable_message_length=True
     ):
-        super(Panel, self).__init__(core, variable_message_length)
+        super().__init__(core, variable_message_length)
 
         self.settings = start_communication_response.fields.value
 
@@ -101,17 +101,17 @@ async def dump_memory_to_file(self, file, range_, ram=False):
             else:
                 args = dict(address=address)
 
-            logger.info("Dumping %s: address %x" % (mem_type, address))
+            logger.info(f"Dumping {mem_type}: address {address:x}")
 
             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=lambda m, a=address: m.fields.value.po.command == 0x5
+                and m.fields.value.address == a,
             )
 
             if reply is None:
-                logger.error("Could not read %s: address %x" % (mem_type, address))
+                logger.error(f"Could not read {mem_type}: address {address:x}")
                 return
 
             data = reply.fields.value.data
@@ -126,7 +126,7 @@ def get_message(self, name: str) -> Construct:
         except ResourceWarning:
             pass
 
-        return super(Panel, self).get_message(name)
+        return super().get_message(name)
 
     def parse_message(
         self, message: bytes, direction="topanel"
@@ -135,7 +135,7 @@ def parse_message(
             if message is None or len(message) == 0:
                 return None
 
-            parent_parsed = super(Panel, self).parse_message(message, direction)
+            parent_parsed = super().parse_message(message, direction)
             if parent_parsed:
                 return parent_parsed
 
@@ -174,9 +174,11 @@ def parse_message(
 
         except ChecksumError as e:
             logger.error(
-                "ChecksumError %s, message: %s" % (str(e), binascii.hexlify(message))
+                "ChecksumError {}, message: {}".format(
+                    str(e), binascii.hexlify(message)
+                )
             )
-        except:
+        except Exception:
             logger.exception(
                 "Exception parsing message: %s" % (binascii.hexlify(message))
             )

paradox/interfaces/__init__.py

@@ -1,8 +1,7 @@
-# -*- coding: utf-8 -*-
-
 import asyncio
 import logging
 import threading
+from typing import Optional
 
 logger = logging.getLogger("PAI").getChild(__name__)
 
@@ -22,7 +21,7 @@ def __init__(self, alarm):
         super().__init__(alarm)
 
         self._loop = asyncio.get_event_loop()
-        self._running_task = None  # type: asyncio.Task
+        self._running_task: Optional[asyncio.Task] = None
 
     def start(self):
         self._running_task = self._loop.create_task(self.run())
@@ -56,7 +55,7 @@ def run(self):
         except (KeyboardInterrupt, SystemExit):
             logger.debug("Interface loop stopping")
             self.stop()
-        except:
+        except Exception:
             logger.exception("Interface loop")
 
     def _run(self):