xaal.lib 0.7.7__py3-none-any.whl → 0.7.8__py3-none-any.whl

xaal/lib/__init__.py

@@ -3,8 +3,8 @@
 # Load main class & modules.
 
 
+from .config import config
 from . import tools
-from . import config
 from . import bindings
 from . import aiohelpers as helpers
 

xaal/lib/aioengine.py

@@ -1,45 +1,80 @@
 import asyncio
-
-from . import core
-from . import config
-from . import tools
-from .messages import MessageParserError
-from .aionetwork import AsyncNetworkConnector
-from .exceptions import *
-
+import logging
+import signal
+import sys
 import time
+import typing
 from enum import Enum
+from pprint import pprint
+from typing import Any, Optional
+from uuid import UUID
+
 import aioconsole
-import signal
-import sys
 from tabulate import tabulate
-from pprint import pprint
 
+from .config import config
+from . import core
+from .aionetwork import AsyncNetworkConnector
+from .exceptions import CallbackError, XAALError
+from .messages import MessageParserError
+
+if typing.TYPE_CHECKING:
+    from .devices import Device
+    from .messages import Message
 
-import logging
 logger = logging.getLogger(__name__)
 
-class AsyncEngine(core.EngineMixin):
 
-    __slots__ = ['__txFifo','_loop','_tasks','_hooks','_watchdog_task','_kill_counter','running_event','watchdog_event','started_event']
+#####################################################
+# Hooks
+#####################################################
+class HookType(Enum):
+    start = 0
+    stop = 1
+
 
-    def __init__(self,address=config.address,port=config.port,hops=config.hops,key=config.key):
-        core.EngineMixin.__init__(self,address,port,hops,key)
+class Hook(object):
+    __slots__ = ['type', 'func', 'args', 'kwargs']
+
+    def __init__(self, type_:HookType, func: core.FuncT, *args, **kwargs):
+        # func has to be a callable, but it can be a coroutine or a function
+        self.type = type_
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
 
-        self.__txFifo = asyncio.Queue()          # tx msg fifo
-        self._loop = None                        # event loop
-        self._hooks = []                         # hooks
-        self._tasks = []                         # tasks
-        self._watchdog_task = None               # watchdog task
-        self._kill_counter = 0                   # watchdog counter
 
-        self.started_event  = asyncio.Event()   # engine started event
-        self.running_event  = asyncio.Event()   # engine running event
-        self.watchdog_event = asyncio.Event()   # watchdog event
+class AsyncEngine(core.EngineMixin):
+    __slots__ = [
+        '__txFifo',
+        '_loop',
+        '_tasks',
+        '_hooks',
+        '_watchdog_task',
+        '_kill_counter',
+        'running_event',
+        'watchdog_event',
+        'started_event',
+    ]
+
+    def __init__(
+        self, address: str = config.address, port: int = config.port, hops: int = config.hops, key: bytes = config.key):
+        core.EngineMixin.__init__(self, address, port, hops, key)
+
+        self.__txFifo = asyncio.Queue()  # tx msg fifo
+        self._loop = None  # event loop
+        self._hooks = []  # hooks
+        self._tasks = []  # tasks
+        self._watchdog_task = None  # watchdog task
+        self._kill_counter = 0  # watchdog counter
+
+        self.started_event = asyncio.Event()  # engine started event
+        self.running_event = asyncio.Event()  # engine running event
+        self.watchdog_event = asyncio.Event()  # watchdog event
 
         signal.signal(signal.SIGTERM, self.sigkill_handler)
         signal.signal(signal.SIGINT, self.sigkill_handler)
-        
+
         # message receive workflow
         self.subscribe(self.handle_request)
         # start network
@@ -48,20 +83,20 @@ class AsyncEngine(core.EngineMixin):
     #####################################################
     # Hooks
     #####################################################
-    def on_start(self,func,*args,**kwargs):
-        hook = Hook(HookType.start,func,*args,**kwargs)
+    def on_start(self, func: core.FuncT, *args, **kwargs):
+        hook = Hook(HookType.start, func, *args, **kwargs)
         self._hooks.append(hook)
-    
-    def on_stop(self,func,*args,**kwargs):
-        hook = Hook(HookType.stop,func,*args,**kwargs)
+
+    def on_stop(self, func: core.FuncT, *args, **kwargs):
+        hook = Hook(HookType.stop, func, *args, **kwargs)
         self._hooks.append(hook)
 
-    async def run_hooks(self,hook_type):
-        hooks = list(filter(lambda hook: hook.type==hook_type,self._hooks))
-        if len(hooks)!=0:
+    async def run_hooks(self, hook_type: HookType):
+        hooks = list(filter(lambda hook: hook.type == hook_type, self._hooks))
+        if len(hooks) != 0:
             logger.debug(f"Launching {hook_type} hooks")
             for h in hooks:
-                await run_func(h.func,*h.args,**h.kwargs)
+                await run_func(h.func, *h.args, **h.kwargs)
 
     #####################################################
     # timers
@@ -77,7 +112,7 @@ class AsyncEngine(core.EngineMixin):
                 except CallbackError as e:
                     logger.error(e.description)
                 if t.counter != -1:
-                    t.counter-= 1
+                    t.counter -= 1
                     if t.counter == 0:
                         expire_list.append(t)
                 t.deadline = now + t.period
@@ -88,20 +123,20 @@ class AsyncEngine(core.EngineMixin):
     #####################################################
     # msg send / receive
     #####################################################
-    def queue_msg(self, msg):
+    def queue_msg(self, msg: bytes):
         """queue a message"""
         self.__txFifo.put_nowait(msg)
 
-    def send_msg(self, msg):
+    def send_msg(self, msg: bytes):
         """Send an encoded message to the bus, use queue_msg instead"""
         self.network.send(msg)
 
-    async def receive_msg(self):
+    async def receive_msg(self) -> Optional['Message']:
         """return new received message or None"""
         data = await self.network.get_data()
         if data:
             try:
-                msg = self.msg_factory.decode_msg(data,self.msg_filter)
+                msg = self.msg_factory.decode_msg(data, self.msg_filter)
             except MessageParserError as e:
                 logger.warning(e)
                 msg = None
@@ -113,27 +148,31 @@ class AsyncEngine(core.EngineMixin):
         msg = await self.receive_msg()
         if msg:
             for func in self.subscribers:
-                await run_func(func,msg)
+                await run_func(func, msg)
             self.process_attributes_change()
 
-    def handle_request(self, msg):
+    def handle_request(self, msg: 'Message'):
         """Filter msg for devices according default xAAL API then process the
         request for each targets identied in the engine
         """
         if not msg.is_request():
             return
+
         targets = core.filter_msg_for_devices(msg, self.devices)
         for target in targets:
-            if msg.action == 'is_alive':
+            if msg.is_request_isalive():
                 self.send_alive(target)
             else:
                 self.new_task(self.handle_action_request(msg, target))
 
-    async def handle_action_request(self, msg, target):
+    async def handle_action_request(self, msg: 'Message', target: 'Device'):
+        if msg.action is None:
+            return # should not happen, but pyright need this check
+
         try:
             result = await run_action(msg, target)
-            if result != None:
-                self.send_reply(dev=target,targets=[msg.source],action=msg.action,body=result)
+            if result is not None and type(result) is dict:
+                self.send_reply(dev=target, targets=[msg.source], action=msg.action, body=result)
         except CallbackError as e:
             self.send_error(target, e.code, e.description)
         except XAALError as e:
@@ -142,25 +181,25 @@ class AsyncEngine(core.EngineMixin):
     #####################################################
     # Asyncio loop & Tasks
     #####################################################
-    def get_loop(self):
-        if self._loop == None:
-            logger.debug('New event loop')
+    def get_loop(self) -> asyncio.AbstractEventLoop:
+        if self._loop is None:
+            logger.debug("New event loop")
             self._loop = asyncio.get_event_loop()
         return self._loop
 
-    def new_task(self,coro,name=None):
+    def new_task(self, coro: Any, name: Optional[str] = None) -> asyncio.Task:
         # we maintain a task list, to be able to stop/start the engine
         # on demand. needed by HASS
-        task = self.get_loop().create_task(coro,name=name)
+        task = self.get_loop().create_task(coro, name=name)
         self._tasks.append(task)
         task.add_done_callback(self.task_callback)
         return task
 
-    def task_callback(self, task):
+    def task_callback(self, task: asyncio.Task):
         # called when a task ended
         self._tasks.remove(task)
 
-    def all_tasks(self):
+    def all_tasks(self) -> typing.List[asyncio.Task]:
         return self._tasks
 
     async def boot_task(self):
@@ -194,106 +233,105 @@ class AsyncEngine(core.EngineMixin):
     async def watchdog_task(self):
         await self.watchdog_event.wait()
         await self.stop()
-        logger.info('Exit')
-    
+        logger.info("Exit")
+
     #####################################################
     # start / stop / shutdown
     #####################################################
-    def is_running(self):
+    def is_running(self) -> bool:
         return self.running_event.is_set()
 
     def start(self):
         if self.is_running():
-            logger.warning('Engine already started')
+            logger.warning("Engine already started")
             return
         self.started_event.set()
-        self.new_task(self.boot_task(),name='Boot')
-        self.new_task(self.receive_task(),name='RecvQ')
-        self.new_task(self.send_task(),name='SendQ')
-        self.new_task(self.timer_task(),name='Timers')
-        self.new_task(console(locals()),name='Console')
+        self.new_task(self.boot_task(), name='Boot')
+        self.new_task(self.receive_task(), name='RecvQ')
+        self.new_task(self.send_task(), name='SendQ')
+        self.new_task(self.timer_task(), name='Timers')
+        self.new_task(console(locals()), name='Console')
 
     def setup_alives_timer(self):
         # needed on stop-start sequence
         if self.process_alives in [t.func for t in self.timers]:
             return
         # process alives every 10 seconds
-        self.add_timer(self.process_alives,10)
+        self.add_timer(self.process_alives, 10)
 
-    async def stop(self):
-        logger.info('Stopping engine')
+    async def stop(self): # pyright: ignore
+        logger.info("Stopping engine")
         await self.run_hooks(HookType.stop)
         self.running_event.clear()
         self.started_event.clear()
         # cancel all tasks
         for task in self.all_tasks():
-            if task!=self._watchdog_task:
+            if task != self._watchdog_task:
                 task.cancel()
                 await asyncio.sleep(0.1)
 
-    def sigkill_handler(self,signal,frame):
-        print("", end = "\r") #remove the uggly ^C
+    def sigkill_handler(self, signal, frame):
+        print("", end="\r")  # remove the uggly ^C
         if not self.is_running():
-            logger.warning('Engine already stopped')
+            logger.warning("Engine already stopped")
             self._kill_counter = 1
-        self._kill_counter +=1
+        self._kill_counter += 1
         self.shutdown()
         if self._kill_counter > 1:
-            logger.warning('Force quit')
+            logger.warning("Force quit")
             sys.exit(-1)
         else:
-            logger.warning('Kill requested')
+            logger.warning("Kill requested")
 
     def shutdown(self):
         self.watchdog_event.set()
-    
+
     def run(self):
         if not self.started_event.is_set():
             self.start()
-        if self._watchdog_task == None:
+        if self._watchdog_task is None:
             # start the watchdog task
-            self._watchdog_task = self.new_task(self.watchdog_task(),name='Watchdog task')
+            self._watchdog_task = self.new_task(self.watchdog_task(), name="Watchdog task")
             self.get_loop().run_until_complete(self._watchdog_task)
         else:
-            logger.warning('Engine already running')
+            logger.warning("Engine already running")
 
     #####################################################
     # Debugging tools
     #####################################################
     def dump_timers(self):
-        headers = ['Func','Period','Counter','Deadline']
+        headers = ['Func', 'Period', 'Counter', 'Deadline']
         rows = []
         now = time.time()
         for t in self.timers:
-            remain = round(t.deadline-now,1)
-            rows.append([str(t.func),t.period,t.counter,remain])
-        print('= Timers')
-        print(tabulate(rows,headers=headers,tablefmt="fancy_grid"))
-
+            remain = round(t.deadline - now, 1)
+            rows.append([str(t.func), t.period, t.counter, remain])
+        print("= Timers")
+        print(tabulate(rows, headers=headers, tablefmt='fancy_grid'))
 
     def dump_tasks(self):
-        headers = ["Name","Coro","Loop ID"]
+        headers = ['Name', 'Coro', 'Loop ID']
         rows = []
         for t in self.all_tasks():
-            rows.append([t.get_name(),str(t.get_coro()),id(t.get_loop())])
-        print('= Tasks')
-        print(tabulate(rows,headers=headers,tablefmt="fancy_grid"))
+            rows.append([t.get_name(), str(t.get_coro()), id(t.get_loop())])
+        print("= Tasks")
+        print(tabulate(rows, headers=headers, tablefmt='fancy_grid'))
 
     def dump_devices(self):
-        headers = ["addr","dev_type","info"]
+        headers = ['addr', 'dev_type', 'info']
         rows = []
         for d in self.devices:
-            rows.append([d.address,d.dev_type,d.info])
-        print('= Devices')
-        print(tabulate(rows,headers=headers,tablefmt="fancy_grid"))
+            rows.append([d.address, d.dev_type, d.info])
+        print("= Devices")
+        print(tabulate(rows, headers=headers, tablefmt='fancy_grid'))
 
     def dump_hooks(self):
-        headers = ["Type","Hook"]
+        headers = ['Type', 'Hook']
         rows = []
         for h in self._hooks:
-            rows.append([h.type,str(h.func)])
-        print('= Hooks')
-        print(tabulate(rows,headers=headers,tablefmt="fancy_grid"))
+            rows.append([h.type, str(h.func)])
+        print("= Hooks")
+        print(tabulate(rows, headers=headers, tablefmt='fancy_grid'))
 
     def dump(self):
         self.dump_devices()
@@ -301,8 +339,8 @@ class AsyncEngine(core.EngineMixin):
         self.dump_timers()
         self.dump_hooks()
 
-    def get_device(self,uuid):
-        uuid = tools.get_uuid(uuid)        
+    def get_device(self, uuid: UUID) -> Optional['Device']:
+        # TODO:Check if this method is usefull 
         for dev in self.devices:
             if dev.address == uuid:
                 return dev
@@ -312,26 +350,26 @@ class AsyncEngine(core.EngineMixin):
 #####################################################
 # Utilities functions
 #####################################################
-async def run_func(func,*args,**kwargs):
-    """run a function or a coroutine function """
+async def run_func(func, *args, **kwargs):
+    """run a function or a coroutine function"""
     if asyncio.iscoroutinefunction(func):
-        return await func(*args,**kwargs)
+        return await func(*args, **kwargs)
     else:
-        return func(*args,**kwargs)
+        return func(*args, **kwargs)
 
 
-async def run_action(msg,device):
-    """ 
+async def run_action(msg: 'Message', device: 'Device'):
+    """
     Extract an action & launch it
     Return:
         - action result
         - None if no result
 
-    Notes: 
+    Notes:
         - If an exception raised, it's logged, and raise an XAALError.
         - Same API as legacy Engine, but accept coroutine functions
     """
-    method,params = core.search_action(msg,device)
+    method, params = core.search_action(msg, device)
     result = None
     try:
         if asyncio.iscoroutinefunction(method):
@@ -340,49 +378,35 @@ async def run_action(msg,device):
             result = method(**params)
     except Exception as e:
         logger.error(e)
-        raise XAALError("Error in method:%s params:%s" % (msg.action,params))
+        raise XAALError("Error in method:%s params:%s" % (msg.action, params))
     return result
 
 
-#####################################################
-# Hooks
-#####################################################
-class HookType(Enum):
-    start = 0
-    stop  = 1
-
-class Hook(object):
-    __slots__ = ['type','func','args','kwargs']
-    def __init__(self,type_,func,*args,**kwargs):
-        self.type = type_
-        self.func = func
-        self.args = args
-        self.kwargs = kwargs
-
-
 #####################################################
 # Debugging console
 #####################################################
-async def console(locals=locals(),port=None):
+async def console(locals=locals(), port: Optional[int] = None):
     """launch a console to enable remote engine inspection"""
-    if port == None:
+    if port is None:
         # let's find a free port if not specified
         def find_free_port():
             import socketserver
-            with socketserver.TCPServer(("localhost", 0), None) as s:
+            with socketserver.TCPServer(('localhost', 0), None) as s: # pyright: ignore pyright reject the None here
                 return s.server_address[1]
+
         port = find_free_port()
-    
-    logger.debug(f'starting debug console on port {port}')
-    sys.ps1 = '[xAAL] >>> '
-    banner = '=' * 78 +"\nxAAL remote console\n" + '=' *78
-    locals.update({'pprint':pprint})
+
+    logger.debug(f"starting debug console on port {port}")
+    sys.ps1 = "[xAAL] >>> "
+    banner = "=" * 78 + "\nxAAL remote console\n" + "=" * 78
+    locals.update({'pprint': pprint})
 
     def factory(streams):
         return aioconsole.AsynchronousConsole(locals=locals, streams=streams)
+
     # start the console
     try:
         # debian with ipv6 disabled still state that localhost is ::1, which broke aioconsole
-        await aioconsole.start_interactive_server(host='127.0.0.1', port=port,factory=factory,banner=banner)
+        await aioconsole.start_interactive_server(host="127.0.0.1", port=port, factory=factory, banner=banner) # pyright: ignore
     except OSError:
-        logger.warning('Unable to run console')
+        logger.warning("Unable to run console")

xaal/lib/aiohelpers.py

@@ -4,8 +4,8 @@ import asyncio
 import logging
 
 @decorator
-def spawn(func,*args,**kwargs):
-    return asyncio.get_event_loop().run_in_executor(None,func,*args,**kwargs)
+def spawn(func, *args, **kwargs):
+    return asyncio.get_event_loop().run_in_executor(None, func, *args, **kwargs)
 
 
 def static_vars(**kwargs_):
@@ -16,20 +16,20 @@ def static_vars(**kwargs_):
     return decorate
 
 
-def run_async_package(pkg_name,pkg_setup,console_log = True,file_log=False):
+def run_async_package(pkg_name, pkg_setup, console_log=True, file_log=False):
     if console_log:
         set_console_title(pkg_name)
         setup_console_logger()
     if file_log:
         setup_file_logger(pkg_name)
-   
-    from .aioengine import AsyncEngine    
+
+    from .aioengine import AsyncEngine
     eng = AsyncEngine()
     eng.start()
     logger = logging.getLogger(pkg_name)
-    logger.info('starting xaal package: %s'% pkg_name )
+    logger.info("starting xaal package: %s"% pkg_name )
     result = pkg_setup(eng)
-    if result != True:
+    if result is not True:
         logger.critical("something goes wrong with package: %s" % pkg_name)
     try:
         eng.run()

xaal/lib/aionetwork.py

@@ -1,14 +1,13 @@
 import asyncio
-import struct
-import socket
-
 import logging
+import socket
+import struct
 
 logger = logging.getLogger(__name__)
 
-class AsyncNetworkConnector(object):
 
-    def __init__(self, addr, port, hops,bind_addr='0.0.0.0'):
+class AsyncNetworkConnector(object):
+    def __init__(self, addr: str, port: int, hops: int, bind_addr="0.0.0.0"):
         self.addr = addr
         self.port = port
         self.hops = hops
@@ -18,57 +17,58 @@ class AsyncNetworkConnector(object):
     async def connect(self):
         loop = asyncio.get_running_loop()
         on_con_lost = loop.create_future()
-        self.transport, self.protocol = await loop.create_datagram_endpoint( 
-            lambda: XAALServerProtocol(on_con_lost,self.receive), sock = self.new_sock())
+        self.transport, self.protocol = await loop.create_datagram_endpoint(
+            lambda: XAALServerProtocol(on_con_lost, self.receive), sock=self.new_sock()
+        )
         # In some conditions (containers), transport is connected but IGMP is delayed (up to 10ms)
         # so we need to wait for IGMP to be really sent.
         await asyncio.sleep(0.05)
 
     def new_sock(self):
-        sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,socket.IPPROTO_UDP)
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
         try:
             # Linux + MacOS + BSD
             sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-        except:
+        except Exception:
             # Windows
             sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         sock.bind((self.bind_addr, self.port))
-        mreq = struct.pack("=4s4s",socket.inet_aton(self.addr),socket.inet_aton(self.bind_addr))
-        sock.setsockopt(socket.IPPROTO_IP,socket.IP_ADD_MEMBERSHIP,mreq)
-        sock.setsockopt(socket.IPPROTO_IP,socket.IP_MULTICAST_TTL,10)
+        mreq = struct.pack("=4s4s", socket.inet_aton(self.addr), socket.inet_aton(self.bind_addr))
+        sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+        sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 10)
         sock.setblocking(False)
         return sock
 
-    def send(self,data):
-        self.protocol.datagram_send(data,self.addr,self.port)
+    def send(self, data: bytes):
+        self.protocol.datagram_send(data, self.addr, self.port)
 
-    def receive(self,data):
+    def receive(self, data: bytes):
         self._rx_queue.put_nowait(data)
 
-    async def get_data(self):
+    async def get_data(self) -> bytes:
         return await self._rx_queue.get()
 
+
 class XAALServerProtocol(asyncio.Protocol):
-    def __init__(self,on_con_lost,on_dtg_recv):
+    def __init__(self, on_con_lost, on_dtg_recv):
         self.on_con_lost = on_con_lost
         self.on_dtg_recv = on_dtg_recv
-        
+
     def connection_made(self, transport):
         logger.info("xAAL network connected")
         self.transport = transport
 
     def error_received(self, exc):
-        print('Error received:', exc)
+        print("Error received:", exc)
         logger.warning(f"Error received: {exc}")
 
     def connection_lost(self, exc):
         logger.info(f"Connexion closed: {exc}")
         self.on_con_lost.set_result(True)
-    
-    def datagram_send(self,data,ip,port):
-        self.transport.sendto(data,(ip,port))
+
+    def datagram_send(self, data, ip, port):
+        self.transport.sendto(data, (ip, port))
 
     def datagram_received(self, data, addr):
-        #print(f"pkt from {addr}")
+        # print(f"pkt from {addr}")
         self.on_dtg_recv(data)
-