Another fix attempt

Author: yozik04

paradox/connections/ip/connection.py

@@ -60,7 +60,7 @@ def __init__(self, host="127.0.0.1", port=10000):
         self.port = port
 
     async def _try_connect(self):
-        _, self._protocol = await asyncio.get_event_loop().create_connection(
+        _, self._protocol = await asyncio.get_running_loop().create_connection(
             self._make_protocol, host=self.host, port=self.port
         )
 
@@ -90,7 +90,7 @@ def set_key(self, value):
         self._protocol.key = value
 
     def on_ip_message(self, container: Container):
-        return asyncio.get_event_loop().create_task(
+        return asyncio.get_running_loop().create_task(
             self.ip_handler_registry.handle(container)
         )
 
@@ -117,7 +117,7 @@ def __init__(
         self.port = port
 
     async def _try_connect(self) -> None:
-        _, self._protocol = await asyncio.get_event_loop().create_connection(
+        _, self._protocol = await asyncio.get_running_loop().create_connection(
             self._make_protocol, host=self.host, port=self.port
         )
 
@@ -148,7 +148,7 @@ def write(self, data: bytes):
 
     async def _try_connect(self) -> None:
         await self.stun_session.connect()
-        _, self._protocol = await asyncio.get_event_loop().create_connection(
+        _, self._protocol = await asyncio.get_running_loop().create_connection(
             self._make_protocol, sock=self.stun_session.get_socket()
         )
 

paradox/connections/ip/stun_session.py

@@ -155,7 +155,7 @@ async def _get_site_info(email, siteid):
         }
 
         tries = 5
-        loop = asyncio.get_event_loop()
+        loop = asyncio.get_running_loop()
         while tries > 0:
             req = await loop.run_in_executor(
                 None,

paradox/connections/serial_connection.py

@@ -64,12 +64,17 @@ async def connect(self) -> bool:
                 logger.error(f"Failed to update file {self.port_path} permissions")
                 return False
 
-        self.connected_future = asyncio.get_event_loop().create_future()
-        open_timeout_handler = asyncio.get_event_loop().call_later(5, self.open_timeout)
+        self.connected_future = asyncio.get_running_loop().create_future()
+        open_timeout_handler = asyncio.get_running_loop().call_later(
+            5, self.open_timeout
+        )
 
         try:
             _, self._protocol = await serial_asyncio.create_serial_connection(
-                asyncio.get_event_loop(), self.make_protocol, self.port_path, self.baud
+                asyncio.get_running_loop(),
+                self.make_protocol,
+                self.port_path,
+                self.baud,
             )
 
             return await self.connected_future

paradox/console_scripts/pai_dump_memory.py

@@ -19,13 +19,6 @@
 from paradox.lib.encodings import register_encodings
 from paradox.paradox import Paradox
 
-if sys.version_info < (3, 6,):
-    print(
-        "You are using Python %s.%s, but PAI requires at least Python 3.6"
-        % (sys.version_info[0], sys.version_info[1])
-    )
-    sys.exit(-1)
-
 logger = logging.getLogger("PAI").getChild(__name__)
 
 
@@ -78,8 +71,7 @@ def main():
     # Registering additional encodings
     register_encodings()
 
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(dump_memory(args.file, args.type))
+    asyncio.run(dump_memory(args.file, args.type))
 
 
 if __name__ == "__main__":

paradox/interfaces/__init__.py

@@ -20,7 +20,7 @@ class AsyncInterface(Interface):
     def __init__(self, alarm):
         super().__init__(alarm)
 
-        self._loop = asyncio.get_event_loop()
+        self._loop = asyncio.get_running_loop()
         self._running_task: Optional[asyncio.Task] = None
 
     def start(self):

paradox/interfaces/ip_interface/interface.py

@@ -39,7 +39,7 @@ def start(self):
             logger.info("No alarm set")
             return
 
-        asyncio.get_event_loop().create_task(self.run())
+        asyncio.get_running_loop().create_task(self.run())
 
     async def run(self):
         try:
@@ -80,5 +80,5 @@ async def handle_client(self, reader, writer):
         finally:
             self.alarm.connection.deregister_raw_handler(handler_name)
 
-            asyncio.get_event_loop().create_task(self.alarm.resume())
+            asyncio.get_running_loop().create_task(self.alarm.resume())
             logger.info("Client %d disconnected", self.client_nr)

paradox/interfaces/text/gsm.py

@@ -118,11 +118,11 @@ async def read(self, timeout=5):
     async def connect(self):
         logger.info(f"Connecting to serial port {self.port_path}")
 
-        self.connected_future = asyncio.get_event_loop().create_future()
-        asyncio.get_event_loop().call_later(5, self.open_timeout)
+        self.connected_future = asyncio.get_running_loop().create_future()
+        asyncio.get_running_loop().call_later(5, self.open_timeout)
 
         _, self.connection = await serial_asyncio.create_serial_connection(
-            asyncio.get_event_loop(), self.make_protocol, self.port_path, self.baud
+            asyncio.get_running_loop(), self.make_protocol, self.port_path, self.baud
         )
 
         return await self.connected_future

paradox/interfaces/text/signal.py

@@ -50,7 +50,7 @@ async def run(self):
 
         logger.debug("Signal Interface Running")
 
-        asyncio.get_event_loop().run_in_executor(None, self.glib_loop.run)
+        asyncio.get_running_loop().run_in_executor(None, self.glib_loop.run)
 
     def send_message(self, message: str, level: EventLevel):
         if self.signal is None:

paradox/lib/async_message_manager.py

@@ -54,11 +54,11 @@ def deregister_handler(self, name):
         self.handler_registry.remove_by_name(name)
 
     def schedule_message_handling(self, message: Container):
-        return asyncio.get_event_loop().create_task(
+        return asyncio.get_running_loop().create_task(
             self.handler_registry.handle(message)
         )
 
     def schedule_raw_message_handling(self, message: Container):
-        return asyncio.get_event_loop().create_task(
+        return asyncio.get_running_loop().create_task(
             self.raw_handler_registry.handle(message)
         )

paradox/main.py

@@ -12,9 +12,6 @@
 from paradox.lib.encodings import register_encodings
 from paradox.paradox import Paradox
 
-alarm = None
-interface_manager = None
-
 logger = logging.getLogger("PAI")
 
 
@@ -53,34 +50,33 @@ def configure_logger(logger):
     logger.setLevel(logger_level)
 
 
-async def exit_handler(signame=None):
-    global alarm, interface_manager
+async def _run(alarm: Paradox):
+    interface_manager = InterfaceManager(alarm, config=cfg)
+    interface_manager.start()
 
-    if signame is not None:
-        logger.info(f"Captured signal {signame}. Exiting")
+    async def exit_handler(signame=None):
+        nonlocal alarm, interface_manager
 
-    if alarm:
-        await alarm.disconnect()
-        alarm = None
+        if signame is not None:
+            logger.info(f"Captured signal {signame}. Exiting")
 
-    if interface_manager:
-        interface_manager.stop()
-        interface_manager = None
+        if alarm:
+            await alarm.disconnect()
+            alarm = None
 
-    logger.info("Good bye!")
+        if interface_manager:
+            interface_manager.stop()
+            interface_manager = None
 
+        logger.info("Good bye!")
 
-async def run_with_signals():
     loop = asyncio.get_running_loop()
     for signame in ("SIGINT", "SIGTERM"):
         sig = getattr(signal, signame)
         loop.add_signal_handler(
             sig, lambda s=signame: asyncio.ensure_future(exit_handler(s))
         )
-    await run_loop()
-
 
-async def run_loop():
     retry = 1
     while alarm is not None:
         logger.info("Starting...")
@@ -118,8 +114,6 @@ async def run_loop():
 
 
 def main(args):
-    global alarm, interface_manager
-
     time.tzset()
     if "config" in args and args.config is not None:
         import os
@@ -140,11 +134,6 @@ def main(args):
     register_encodings()
 
     # Start interacting with the alarm
-    alarm = Paradox()
-
-    interface_manager = InterfaceManager(alarm, config=cfg)
-    interface_manager.start()
-
-    asyncio.run(run_with_signals())
+    asyncio.run(_run(Paradox()))
 
     sys.exit(0)