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

xaal/lib/helpers.py

@@ -1,4 +1,4 @@
-""" 
+"""
 This file contains some helpers functions. This functions aren't used in the lib itself
 but can be usefull for xaal packages developpers
 """
@@ -7,42 +7,50 @@ import logging
 import logging.handlers
 import os
 import time
+from typing import Any, Optional
+
 import coloredlogs
 from decorator import decorator
 
-from . import config
+from .config import config
+
 
 def singleton(class_):
-  instances = {}
-  def getinstance(*args, **kwargs):
-    if class_ not in instances:
-        instances[class_] = class_(*args, **kwargs)
-    return instances[class_]
-  return getinstance
+    instances = {}
+
+    def getinstance(*args, **kwargs):
+        if class_ not in instances:
+            instances[class_] = class_(*args, **kwargs)
+        return instances[class_]
+
+    return getinstance
 
 
 @decorator
-def timeit(method,*args,**kwargs):
+def timeit(method, *args, **kwargs):
     logger = logging.getLogger(__name__)
     ts = time.time()
     result = method(*args, **kwargs)
     te = time.time()
-    logger.debug('%r (%r, %r) %2.6f sec' % (method.__name__, args, kwargs, te-ts))
+    logger.debug("%r (%r, %r) %2.6f sec" % (method.__name__, args, kwargs, te - ts))
     return result
 
-def set_console_title(value):
+
+def set_console_title(value: str):
     # set xterm title
-    print("\x1B]0;xAAL => %s\x07" % value,end='\r')
+    print("\x1b]0;xAAL => %s\x07" % value, end="\r")
 
-def setup_console_logger(level=config.log_level):
-    fmt = '%(asctime)s %(name)-25s %(funcName)-18s %(levelname)-8s %(message)s'
-    #fmt = '[%(name)s] %(funcName)s %(levelname)s: %(message)s'
-    coloredlogs.install(level=level,fmt=fmt)
 
-def setup_file_logger(name,level=config.log_level,filename = None):
-    filename = filename or os.path.join(config.log_path,'%s.log' % name)
-    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(name)s - %(message)s')
-    handler = logging.handlers.RotatingFileHandler(filename, 'a', 10000, 1, 'utf8')
+def setup_console_logger(level: str = config.log_level):
+    fmt = "%(asctime)s %(name)-25s %(funcName)-18s %(levelname)-8s %(message)s"
+    # fmt = '[%(name)s] %(funcName)s %(levelname)s: %(message)s'
+    coloredlogs.install(level=level, fmt=fmt)
+
+
+def setup_file_logger(name: str, level: str = config.log_level, filename: Optional[str] = None):
+    filename = filename or os.path.join(config.log_path, "%s.log" % name)
+    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(name)s - %(message)s")
+    handler = logging.handlers.RotatingFileHandler(filename, "a", 10000, 1, "utf8")
     handler.setLevel(level)
     handler.setFormatter(formatter)
     # register the new handler
@@ -50,26 +58,28 @@ def setup_file_logger(name,level=config.log_level,filename = None):
     logger.root.addHandler(handler)
     logger.root.setLevel('DEBUG')
 
+
 # ---------------------------------------------------------------------------
-# TBD: We should merge this stuffs, and add support for default config file 
-#      and commnand line parsing. 
-# 
+# TBD: We should merge this stuffs, and add support for default config file
+#      and commnand line parsing.
+#
 # Default arguments console_log and file_log are (and should) never be used.
 # ---------------------------------------------------------------------------
-def run_package(pkg_name,pkg_setup,console_log = True,file_log=False):
+def run_package(pkg_name: str, pkg_setup: Any, console_log: bool = True, file_log: bool = False):
     if console_log:
         set_console_title(pkg_name)
         setup_console_logger()
     if file_log:
         setup_file_logger(pkg_name)
     logger = logging.getLogger(pkg_name)
-    logger.info('starting xaal package: %s'% pkg_name )
+    logger.info("starting xaal package: %s" % pkg_name)
 
     from .engine import Engine
+
     eng = Engine()
     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()
@@ -77,4 +87,5 @@ def run_package(pkg_name,pkg_setup,console_log = True,file_log=False):
         eng.shutdown()
         logger.info("exit")
 
-__all__ = ['singleton','timeit','set_console_title','setup_console_logger','setup_file_logger','run_package']
+
+__all__ = ['singleton', 'timeit', 'set_console_title', 'setup_console_logger', 'setup_file_logger', 'run_package']

xaal/lib/messages.py

@@ -18,26 +18,139 @@
 #  along with xAAL. If not, see <http://www.gnu.org/licenses/>.
 #
 
-from . import tools
-from . import config
+import datetime
+import logging
+import pprint
+import struct
+import typing
+from enum import Enum
+from typing import Any, Optional
+
+import pysodium
+from tabulate import tabulate
+
+from . import cbor, tools
 from .bindings import UUID
+from .config import config
 from .exceptions import MessageError, MessageParserError
-from . import cbor
 
-from enum import Enum
-from tabulate import tabulate
-import pprint
-import datetime
-import pysodium
-import struct
-import sys
+if typing.TYPE_CHECKING:
+    from .devices import Device
+
 
-import logging
 logger = logging.getLogger(__name__)
 
 ALIVE_ADDR = UUID("00000000-0000-0000-0000-000000000000")
 
 
+class MessageType(Enum):
+    NOTIFY = 0
+    REQUEST = 1
+    REPLY = 2
+
+
+class MessageAction(Enum):
+    ALIVE = 'alive'
+    IS_ALIVE = 'is_alive'
+    ATTRIBUTES_CHANGE = 'attributes_change'
+    GET_ATTRIBUTES = 'get_attributes'
+    GET_DESCRIPTION = 'get_description'
+
+
+class Message(object):
+    """Message object used for incomming & outgoint message"""
+
+    __slots__ = ['version', 'timestamp', 'source', 'dev_type', 'msg_type', 'action', 'body', '__targets']
+
+    def __init__(self):
+        self.version = config.STACK_VERSION  # message API version
+        self.__targets = []  # target property
+        self.timestamp: tuple = ()  # message timestamp
+        self.source: Optional[UUID] = None  # message source
+        self.dev_type: Optional[str] = None  # message dev_type
+        self.msg_type: Optional[MessageType] = None  # message type
+        self.action: Optional[str] = None  # message action
+        self.body = {}  # message body
+
+    @property
+    def targets(self) -> list:
+        return self.__targets
+
+    @targets.setter
+    def targets(self, values: list):
+        if not isinstance(values, list):
+            raise MessageError("Expected a list for targetsList, got %s" % (type(values),))
+        for uid in values:
+            if not tools.is_valid_address(uid):
+                raise MessageError("Bad target addr: %s" % uid)
+        self.__targets = values
+
+    def targets_as_string(self) -> list:
+        return [str(k) for k in self.targets]
+
+    def dump(self):
+        r = []
+        r.append(['version', self.version])
+        r.append(['targets', str(self.targets)])
+        r.append(['timestamp', str(self.timestamp)])
+        r.append(['source', self.source])
+        r.append(['dev_type', self.dev_type])
+        r.append(['msg_type', MessageType(self.msg_type)])
+        r.append(['action', self.action])
+        if self.body:
+            tmp = ""
+            for k, v in self.body.items():
+                k = k + ":"
+                v = pprint.pformat(v, width=55)
+                tmp = tmp + "- %-12s %s\n" % (k, v)
+            # tmp = tmp.strip()
+            r.append(['body', tmp])
+        print(tabulate(r, headers=['Field', 'Value'], tablefmt='psql'))
+
+    def __repr__(self) -> str:
+        return f"<xaal.Message {id(self):x} {self.source} {self.dev_type} {self.msg_type} {self.action}>"
+
+    def is_request(self) -> bool:
+        if MessageType(self.msg_type) == MessageType.REQUEST:
+            return True
+        return False
+
+    def is_reply(self) -> bool:
+        if MessageType(self.msg_type) == MessageType.REPLY:
+            return True
+        return False
+
+    def is_notify(self) -> bool:
+        if MessageType(self.msg_type) == MessageType.NOTIFY:
+            return True
+        return False
+
+    def is_alive(self) -> bool:
+        if self.is_notify() and self.action == MessageAction.ALIVE.value:
+            return True
+        return False
+
+    def is_request_isalive(self) -> bool:
+        if self.is_request() and self.action == MessageAction.IS_ALIVE.value:
+            return True
+        return False
+
+    def is_attributes_change(self) -> bool:
+        if self.is_notify() and self.action == MessageAction.ATTRIBUTES_CHANGE.value:
+            return True
+        return False
+
+    def is_get_attribute_reply(self) -> bool:
+        if self.is_reply() and self.action == MessageAction.GET_ATTRIBUTES.value:
+            return True
+        return False
+
+    def is_get_description_reply(self) -> bool:
+        if self.is_reply() and self.action == MessageAction.GET_DESCRIPTION.value:
+            return True
+        return False
+
+
 class MessageFactory(object):
     """Message Factory:
     - Build xAAL message
@@ -45,9 +158,10 @@ class MessageFactory(object):
     - Serialize/Deserialize data in CBOR"""
 
     def __init__(self, cipher_key):
-        self.cipher_key = cipher_key    # key encode / decode message built from passphrase
+        # key encode / decode message built from passphrase
+        self.cipher_key = cipher_key
 
-    def encode_msg(self, msg):
+    def encode_msg(self, msg: Message) -> bytes:
         """Apply security layer and return encode MSG in CBOR
         :param msg: xAAL msg instance
         :type msg: Message
@@ -65,6 +179,10 @@ class MessageFactory(object):
 
         # Format payload & ciphering
         buf = []
+        if not msg.source:
+            raise MessageError("No source address in message")
+        if not msg.msg_type:
+            raise MessageError("No msg_type in message")
         buf.append(msg.source.bytes)
         buf.append(msg.dev_type)
         buf.append(msg.msg_type.value)
@@ -73,8 +191,8 @@ class MessageFactory(object):
             buf.append(msg.body)
         clear = cbor.dumps(buf)
         # Additionnal Data == cbor serialization of the targets array
-        ad      = result[3]
-        nonce   = build_nonce(msg.timestamp)
+        ad = result[3]
+        nonce = build_nonce(msg.timestamp)
         payload = pysodium.crypto_aead_chacha20poly1305_ietf_encrypt(clear, ad, nonce, self.cipher_key)
 
         # Final CBOR serialization
@@ -82,7 +200,7 @@ class MessageFactory(object):
         pkt = cbor.dumps(result)
         return pkt
 
-    def decode_msg(self, data, filter_func=None):
+    def decode_msg(self, data: bytes, filter_func: Any = None) -> Optional[Message]:
         """Decode incoming CBOR data and De-Ciphering
         :param data: data received from the multicast bus
         :type data: cbor
@@ -94,17 +212,17 @@ class MessageFactory(object):
         # Decode cbor incoming data
         try:
             data_rx = cbor.loads(data)
-        except:
+        except Exception:
             raise MessageParserError("Unable to parse CBOR data")
 
         # Instanciate Message, parse the security layer
         msg = Message()
         try:
-            msg.version   = data_rx[0]
-            msg_time      = data_rx[1]
-            targets       = cbor.loads(data_rx[3])
-            msg.targets   = [UUID(bytes=t) for t in targets]
-            msg.timestamp = [data_rx[1], data_rx[2]]
+            msg.version = data_rx[0]
+            msg_time = data_rx[1]
+            targets = cbor.loads(data_rx[3])
+            msg.targets = [UUID(bytes=t) for t in targets]
+            msg.timestamp = (data_rx[1], data_rx[2])
         except IndexError:
             raise MessageParserError("Bad Message, wrong fields")
 
@@ -116,7 +234,7 @@ class MessageFactory(object):
         # Replay attack, window fixed to CIPHER_WINDOW in seconds
         now = build_timestamp()[0]  # test done only on seconds ...
         if msg_time < (now - config.cipher_window):
-            raise MessageParserError("Potential replay attack, message too old: %d sec" % round(now - msg_time) )
+            raise MessageParserError("Potential replay attack, message too old: %d sec" % round(now - msg_time))
 
         if msg_time > (now + config.cipher_window):
             raise MessageParserError("Potential replay attack, message too young: %d sec" % round(now - msg_time))
@@ -132,19 +250,19 @@ class MessageFactory(object):
         nonce = build_nonce(msg.timestamp)
         try:
             clear = pysodium.crypto_aead_chacha20poly1305_ietf_decrypt(ciph, ad, nonce, self.cipher_key)
-        except :
+        except Exception:
             raise MessageParserError("Unable to decrypt msg")
 
         # Decode application layer (payload)
         try:
             payload = cbor.loads(clear)
-        except:
+        except Exception:
             raise MessageParserError("Unable to parse CBOR data in payload after decrypt")
         try:
-            msg.source  = UUID(bytes=payload[0])
+            msg.source = UUID(bytes=payload[0])
             msg.dev_type = payload[1]
             msg.msg_type = payload[2]
-            msg.action   = payload[3]
+            msg.action = payload[3]
         except IndexError:
             raise MessageParserError("Unable to parse payload headers")
         if len(payload) == 5:
@@ -160,7 +278,14 @@ class MessageFactory(object):
     #####################################################
     # MSG builder
     #####################################################
-    def build_msg(self, dev=None, targets=[], msg_type=None, action=None, body=None):
+    def build_msg(
+        self,
+        dev: Optional['Device'] = None,
+        targets: list = [],
+        msg_type: Optional[MessageType] = None,
+        action: Optional[str] = None,
+        body: Optional[dict] = None,
+    ):
         """the build method takes in parameters :
         -A device
         -The list of targets of the message
@@ -187,150 +312,47 @@ class MessageFactory(object):
         data = self.encode_msg(message)
         return data
 
-    def build_alive_for(self, dev, timeout=0):
+    def build_alive_for(self, dev: 'Device', timeout: int = 0) -> bytes:
         """Build Alive message for a given device
         timeout = 0 is the minimum value
         """
         body = {}
         body['timeout'] = timeout
-        message = self.build_msg(dev=dev, targets=[], msg_type=MessageType.NOTIFY, action=MessageAction.ALIVE.value, body=body)
+        message = self.build_msg(
+            dev=dev, targets=[], msg_type=MessageType.NOTIFY, action=MessageAction.ALIVE.value, body=body
+        )
         return message
 
-    def build_error_msg(self, dev, errcode, description=None):
+    def build_error_msg(self, dev: 'Device', errcode: int, description: Optional[str] = None):
         """Build a Error message"""
         message = Message()
         body = {}
         body['code'] = errcode
         if description:
             body['description'] = description
-        message = self.build_msg(dev, [], MessageType.NOTIFY, "error", body)
+        message = self.build_msg(dev, [], MessageType.NOTIFY, 'error', body)
         return message
 
 
-class MessageType(Enum):
-    NOTIFY  = 0
-    REQUEST = 1
-    REPLY   = 2
-
-
-class MessageAction(Enum):
-    ALIVE             = "alive"
-    IS_ALIVE          = "is_alive"
-    ATTRIBUTES_CHANGE = "attributes_change"
-    GET_ATTRIBUTES    = "get_attributes"
-    GET_DESCRIPTION   = "get_description"
-
-
-class Message(object):
-    """Message object used for incomming & outgoint message"""
-
-    __slots__ = ['version', 'timestamp', 'source', 'dev_type', 'msg_type', 'action', 'body', '__targets']
-
-    def __init__(self):
-        self.version = config.STACK_VERSION  # message API version
-        self.__targets = []                  # target property
-        self.timestamp = None                # message timestamp
-        self.source = None                   # message source
-        self.dev_type = None                 # message dev_type
-        self.msg_type = None                 # message type
-        self.action  = None                  # message action
-        self.body = {}                       # message body
-
-    @property
-    def targets(self):
-        return self.__targets
-
-    @targets.setter
-    def targets(self, values):
-        if not isinstance(values, list):
-            raise MessageError("Expected a list for targetsList, got %s" % (type(values),))
-        for uid in values:
-            if not tools.is_valid_address(uid):
-                raise MessageError("Bad target addr: %s" % uid)
-        self.__targets = values
-
-    def targets_as_string(self):
-        return [str(k) for k in self.targets]
-
-    def dump(self):
-        r = []
-        r.append(["version", self.version])
-        r.append(["targets", str(self.targets)])
-        r.append(["timestamp", str(self.timestamp)])
-        r.append(["source", self.source])
-        r.append(["dev_type", self.dev_type])
-        r.append(["msg_type", MessageType(self.msg_type)])
-        r.append(["action", self.action])
-        if self.body:
-            tmp=""
-            for  k,v in self.body.items():
-                k = k + ':'
-                v = pprint.pformat(v,width=55)
-                tmp = tmp+"- %-12s %s\n" % (k,v)
-            #tmp = tmp.strip()
-            r.append(["body", tmp])
-        print(tabulate(r, headers=["Fied", "Value"], tablefmt="psql"))
-
-    def __repr__(self):
-        return f"<xaal.Message {id(self):x} {self.source} {self.dev_type} {self.msg_type} {self.action}>"
-
-    def is_request(self):
-        if MessageType(self.msg_type) == MessageType.REQUEST:
-            return True
-        return False
-
-    def is_reply(self):
-        if MessageType(self.msg_type) == MessageType.REPLY:
-            return True
-        return False
-
-    def is_notify(self):
-        if MessageType(self.msg_type) == MessageType.NOTIFY:
-            return True
-        return False
-
-    def is_alive(self):
-        if self.is_notify() and self.action == MessageAction.ALIVE.value:
-            return True
-        return False
-
-    def is_request_isalive(self):
-        if self.is_request() and self.action == MessageAction.IS_ALIVE.value:
-            return True
-        return False
-
-    def is_attributes_change(self):
-        if self.is_notify() and self.action == MessageAction.ATTRIBUTES_CHANGE.value:
-            return True
-        return False
-
-    def is_get_attribute_reply(self):
-        if self.is_reply() and self.action == MessageAction.GET_ATTRIBUTES.value:
-            return True
-        return False
-
-    def is_get_description_reply(self):
-        if self.is_reply() and self.action == MessageAction.GET_DESCRIPTION.value:
-            return True
-        return False
-
-
-def build_nonce(data):
-    """ Big-Endian, time in seconds and time in microseconds """
-    nonce = struct.pack('>QL', data[0], data[1])
+def build_nonce(data: tuple) -> bytes:
+    """Big-Endian, time in seconds and time in microseconds"""
+    nonce = struct.pack(">QL", data[0], data[1])
     return nonce
 
 
-def build_timestamp():
+def build_timestamp() -> tuple:
     """Return array [seconds since epoch, microseconds since last seconds] Time = UTC+0000"""
     epoch = datetime.datetime.fromtimestamp(0, datetime.UTC)
     timestamp = datetime.datetime.now(datetime.UTC) - epoch
-    return _packtimestamp(timestamp.total_seconds(), timestamp.microseconds)
+    return (int(timestamp.total_seconds()), int(timestamp.microseconds))
+
 
+## This stuff below is for Py2/Py3 compatibility. In the current state of xAAL, we only use
+# Py3. This code is here for archive purpose and could be removed in the future.
 
 # for better performance, I choose to use this trick to fix the change in size for Py3.
 # only test once.
-if sys.version_info.major == 2:
-    _packtimestamp = lambda t1,t2: [long(t1),int(t2)]
-else:
-    _packtimestamp = lambda t1,t2: [int(t1),int(t2)]
+# if sys.version_info.major == 2:
+#    _packtimestamp = lambda t1, t2: (long(t1), int(t2)) # pyright: ignore
+# else:
+#    _packtimestamp = lambda t1, t2: (int(t1), int(t2))

xaal/lib/network.py

@@ -18,25 +18,26 @@
 #  along with xAAL. If not, see <http://www.gnu.org/licenses/>.
 #
 
+import logging
+import select
 import socket
 import struct
-import select
-import logging
+import time
+from enum import Enum
+from typing import Optional
 
 logger = logging.getLogger(__name__)
 
-import time
-from enum import Enum
 
 class NetworkState(Enum):
     disconnected = 0
-    connected    = 1
+    connected = 1
 
 
 class NetworkConnector(object):
     UDP_MAX_SIZE = 65507
 
-    def __init__(self, addr, port, hops,bind_addr='0.0.0.0'):
+    def __init__(self, addr: str, port: int, hops: int, bind_addr="0.0.0.0"):
         self.addr = addr
         self.port = port
         self.hops = hops
@@ -52,14 +53,14 @@ class NetworkConnector(object):
     def __connect(self):
         logger.info("Connecting to %s:%s" % (self.addr, self.port))
 
-        self.__sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,socket.IPPROTO_UDP)
+        self.__sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
         self.__sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
         # #formac os ???
-        #self.__sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        # self.__sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         self.__sock.bind((self.bind_addr, self.port))
-        mreq = struct.pack("=4s4s",socket.inet_aton(self.addr),socket.inet_aton(self.bind_addr))
-        self.__sock.setsockopt(socket.IPPROTO_IP,socket.IP_ADD_MEMBERSHIP,mreq)
-        self.__sock.setsockopt(socket.IPPROTO_IP,socket.IP_MULTICAST_TTL,self.hops)
+        mreq = struct.pack("=4s4s", socket.inet_aton(self.addr), socket.inet_aton(self.bind_addr))
+        self.__sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+        self.__sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, self.hops)
         self.state = NetworkState.connected
 
     def disconnect(self):
@@ -70,31 +71,33 @@ class NetworkConnector(object):
     def is_connected(self):
         return self.state == NetworkState.connected
 
-    def receive(self):
+    def receive(self) -> bytes:
         packt = self.__sock.recv(self.UDP_MAX_SIZE)
         return packt
 
-    def __get_data(self):
-        r = select.select([self.__sock, ], [], [], 0.02)
+    def __get_data(self) -> Optional[bytes]:
+        r = select.select([self.__sock,], [], [], 0.02)
         if r[0]:
             return self.receive()
         return None
 
-    def get_data(self):
-        if not self.is_connected(): self.connect()
+    def get_data(self) -> Optional[bytes]:
+        if not self.is_connected():
+            self.connect()
         try:
             return self.__get_data()
         except Exception as e:
             self.network_error(e)
 
-    def send(self,data):
-        if not self.is_connected(): self.connect()
+    def send(self, data: bytes):
+        if not self.is_connected():
+            self.connect()
         try:
             self.__sock.sendto(data, (self.addr, self.port))
         except Exception as e:
             self.network_error(e)
 
-    def network_error(self, msg):
+    def network_error(self, ex: Exception):
         self.disconnect()
-        logger.info("Network error, reconnect..%s" % msg)
+        logger.info("Network error, reconnect..%s" % ex.__str__())
         time.sleep(5)