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

xaal/lib/bindings.py

@@ -2,86 +2,86 @@ import uuid
 
 from .exceptions import UUIDError
 
+
 class UUID:
-    def __init__(self,*args,**kwargs):
-        self.__uuid = uuid.UUID(*args,**kwargs)
+    def __init__(self, *args, **kwargs):
+        self.__uuid = uuid.UUID(*args, **kwargs)
 
     @staticmethod
-    def random_base(digit=2):
+    def random_base(digit=2) -> 'UUID':
         """zeros the last digits of a random uuid, usefull w/ you want to forge some addresses
-            two digit is great.
+        two digit is great.
         """
-        if (digit > 0)  and  (digit < 13): 
+        if (digit > 0) and (digit < 13):
             tmp = str(uuid.uuid1())
-            st = "%s%s" % (tmp[:-digit],'0'*digit)
+            st = "%s%s" % (tmp[:-digit], '0' * digit)
             return UUID(st)
         else:
             raise UUIDError
 
     @staticmethod
-    def random():
+    def random() -> 'UUID':
         tmp = uuid.uuid1().int
         return UUID(int=tmp)
 
-    def __add__(self,value):
+    def __add__(self, value: int) -> 'UUID':
         tmp = self.__uuid.int + value
         return UUID(int=tmp)
 
-    def __sub__(self,value):
+    def __sub__(self, value: int) -> 'UUID':
         tmp = self.__uuid.int - value
         return UUID(int=tmp)
 
-    def __eq__(self,value):
+    def __eq__(self, value) -> bool:
         return self.__uuid == value
 
-    def __lt__(self, value ):
+    def __lt__(self, value) -> bool:
         return self.__uuid.int < value
 
-    def __gt__(self, value ):
+    def __gt__(self, value) -> bool:
         return self.__uuid.int > value
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.__uuid)
-    
-    def __repr__(self): # pragma: no cover
+
+    def __repr__(self) -> str:  # pragma: no cover
         return f"UUID('{self.__uuid}')"
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return self.__uuid.__hash__()
 
-    def get(self):
+    def get(self) -> uuid.UUID:
         return self.__uuid
-    
-    def set(self,value):
+
+    def set(self, value: uuid.UUID):
         self.__uuid = value
 
     @property
-    def str(self):
+    def str(self) -> str:
         return str(self)
 
     @property
-    def bytes(self):
+    def bytes(self) -> bytes:
         return self.__uuid.bytes
 
 
-
 class URL:
-    def __init__(self,value):
+    def __init__(self, value):
         self.__url = value
 
-    def __eq__(self,value):
+    def __eq__(self, value):
         return self.__url == value
 
     def __str__(self):
         return str(self.__url)
-    
-    def __repr__(self): # pragma: no cover
-        return f"URL('{self.__url}')" 
 
-    def set(self,value):
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"URL('{self.__url}')"
+
+    def set(self, value: str):
         self.__url = value
 
-    def get(self):
+    def get(self) -> str:
         return self.__url
 
     @property
@@ -93,6 +93,4 @@ class URL:
         return self.__url
 
 
-
-classes = [UUID,URL]
-
+classes = [UUID, URL]

xaal/lib/cbor.py

@@ -16,25 +16,30 @@ def tag_hook(decoder, tag, shareable_index=None):
         return bindings.URL(tag.value)
     return tag
 
+
 def default_encoder(encoder, value):
-    if isinstance(value,bindings.UUID):
+    if isinstance(value, bindings.UUID):
         encoder.encode(CBORTag(37, value.bytes))
 
-    if isinstance(value,bindings.URL):
+    if isinstance(value, bindings.URL):
         encoder.encode(CBORTag(32, value.bytes))
 
+
 def dumps(obj, **kwargs):
-    return cbor2.dumps(obj,default=default_encoder,**kwargs)
+    return cbor2.dumps(obj, default=default_encoder, **kwargs)
+
 
 def loads(payload, **kwargs):
-    #return cbor2.loads(payload,tag_hook=tag_hook,**kwargs)
-    return _loads(payload,tag_hook=tag_hook,**kwargs)
+    # return cbor2.loads(payload,tag_hook=tag_hook,**kwargs)
+    return _loads(payload, tag_hook=tag_hook, **kwargs)
+
 
 def _loads(s, **kwargs):
     with BytesIO(s) as fp:
         return CBORDecoder(fp, **kwargs).decode()
 
-#class CustomDecoder(CBORDecoder):pass
+
+# class CustomDecoder(CBORDecoder):pass
 
 
 def cleanup(obj):
@@ -45,14 +50,14 @@ def cleanup(obj):
     Warning: This operate in-place changes.
     Warning: This won't work for tags in dict keys.
     """
-    if isinstance(obj,list):
-        for i in range(0,len(obj)):
+    if isinstance(obj, list):
+        for i in range(0, len(obj)):
             obj[i] = cleanup(obj[i])
         return obj
 
-    if isinstance(obj,dict):
+    if isinstance(obj, dict):
         for k in obj.keys():
-            obj.update({k:cleanup(obj[k])})
+            obj.update({k: cleanup(obj[k])})
         return obj
 
     if type(obj) in bindings.classes:

xaal/lib/config.py

@@ -1,53 +1,82 @@
 
 # Default configuration
+
 import os
 import sys
 import binascii
 from configobj import ConfigObj
 
-self = sys.modules[__name__]
-
 # Default settings
-DEF_ADDR = '224.0.29.200'       # mcast address
-DEF_PORT = 1236                 # mcast port
-DEF_HOPS = 10                   # mcast hop
-DEF_ALIVE_TIMER = 100           # Time between two alive msg
-DEF_CIPHER_WINDOW = 60 * 2      # Time Window in seconds to avoid replay attacks
-DEF_QUEUE_SIZE = 10             # How many packet we can send in one loop
-DEF_LOG_LEVEL = 'DEBUG'         # should be INFO|DEBUG|None
-DEF_LOG_PATH  = '/var/log/xaal' # where log are 
-
-# TBD : Move this stuff
+DEF_ADDR = '224.0.29.200'
+DEF_PORT = 1236
+DEF_HOPS = 10
+DEF_ALIVE_TIMER = 100
+DEF_CIPHER_WINDOW = 60 * 2
+DEF_QUEUE_SIZE = 10
+DEF_LOG_LEVEL = 'DEBUG'
+DEF_LOG_PATH = '/var/log/xaal'
+
 STACK_VERSION = 7
 
+class Config:
+    def __init__(self):
+        self.conf_dir = os.environ.get('XAAL_CONF_DIR', os.path.expanduser("~/.xaal"))
+        self.address = DEF_ADDR
+        self.port = DEF_PORT
+        self.hops = DEF_HOPS
+        self.alive_timer = DEF_ALIVE_TIMER
+        self.cipher_window = DEF_CIPHER_WINDOW
+        self.queue_size = DEF_QUEUE_SIZE
+        self.log_level = DEF_LOG_LEVEL
+        self.log_path = DEF_LOG_PATH
+        self.key = b''
+        self.STACK_VERSION = STACK_VERSION
+
+    def load(self, name='xaal.ini'):
+        filename = os.path.join(self.conf_dir, name)
+        if not os.path.isfile(filename):
+            raise FileNotFoundError(f"Unable to load xAAL config file [{filename}]")
+
+        cfg = ConfigObj(filename)
+        self.address = self.safe_string(cfg.get('address'), DEF_ADDR)
+        self.port = self.safe_int(cfg.get('port'), DEF_PORT)
+        self.hops = self.safe_int(cfg.get('hops'), DEF_HOPS)
+        self.alive_timer = self.safe_int(cfg.get('alive_timer'), DEF_ALIVE_TIMER)
+        self.cipher_window = self.safe_int(cfg.get('cipher_window'), DEF_CIPHER_WINDOW)
+        self.queue_size = self.safe_int(cfg.get('queue_size'), DEF_QUEUE_SIZE)
+        self.log_level = self.safe_string(cfg.get('log_level'), DEF_LOG_LEVEL)
+        self.log_path = self.safe_string(cfg.get('log_path'), DEF_LOG_PATH)
+        key = cfg.get('key', None)
+        if key and type(key) is str:
+            self.key = binascii.unhexlify(key.encode('utf-8'))
+        else:
+            raise ValueError(f"Key not set in config file [{filename}]")
+
+    ## Helper functions
+    # Pylint enforce to sanity check the input. In fact, ConfigObj can do the job without issue
+    # but Pytlint assume cfg.get can return None (even w/ default set), so it warm about wrong
+    # type in all config setting. By doing this I insure that the value is of the right type.
+
+    @staticmethod
+    def safe_int(value, default):
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return default
+
+    @staticmethod
+    def safe_string(value, default):
+        if value is None:
+            return default
+        try:
+            return str(value)
+        except (ValueError, TypeError):
+            return default
+
 
-if 'XAAL_CONF_DIR' in os.environ:
-    self.conf_dir = os.environ['XAAL_CONF_DIR']
-else:
-    self.conf_dir = os.path.expanduser("~") + '/.xaal'
-
-
-def load_config(name='xaal.ini'):
-    filename = os.path.join(self.conf_dir, name)
-    if not os.path.isfile(filename):
-        print("Unable to load xAAL config file [%s]" % filename)
-        sys.exit(-1)
-
-    cfg = ConfigObj(filename)
-    self.address       = cfg.get('address',DEF_ADDR)
-    self.port          = int(cfg.get('port',DEF_PORT))
-    self.hops          = int(cfg.get('hops',DEF_HOPS))
-    self.alive_timer   = int(cfg.get('alive_timer',DEF_ALIVE_TIMER))
-    self.cipher_window = int(cfg.get('ciper_window',DEF_CIPHER_WINDOW))
-    self.queue_size    = int(cfg.get('queue_size',DEF_QUEUE_SIZE))
-    self.log_level     = cfg.get('log_level',DEF_LOG_LEVEL)
-    self.log_path      = cfg.get('log_path',DEF_LOG_PATH)
-    key = cfg.get('key',None)
-
-    if key:
-        self.key = binascii.unhexlify(key.encode('utf-8'))
-    else:
-        print("Please set key in config file [%s]" % filename)
-        self.key = None
-
-load_config()
+config = Config()
+try:
+    config.load()
+except Exception as e:
+    print(e)
+    sys.exit(-1)

xaal/lib/core.py

@@ -18,26 +18,50 @@
 #  along with xAAL. If not, see <http://www.gnu.org/licenses/>.
 #
 
-from .messages import MessageType, MessageAction, MessageFactory, ALIVE_ADDR
-from .exceptions  import *
-
-import time
 import inspect
-
 import logging
+import time
+import typing
+from typing import Any, Awaitable, Optional, List, Callable, Union
+
+from .exceptions import EngineError, XAALError
+from .messages import ALIVE_ADDR, MessageAction, MessageFactory, MessageType
+
+if typing.TYPE_CHECKING:
+    from .devices import Device, Attribute
+    from .messages import Message
+
+# Function type w/ no argument, and no return (Timer, Hooks)
+FuncT = Union[Callable[[], None], Callable[[], Awaitable[None]]]
+
+# Function type w/ message as argument (subscribers), no return
+SubFuncT = Union[Callable[['Message'], None], Callable[['Message'], Awaitable[None]]]
+
 logger = logging.getLogger(__name__)
 
-class EngineMixin(object):
 
-    __slots__ = ['devices','timers','subscribers','msg_filter','_attributesChange','network','msg_factory']
+#####################################################
+# Timer class
+#####################################################
+class Timer(object):
+    def __init__(self, func: FuncT, period: int, counter: int):
+        # Timer function should a Callable[[],None], but it can be a coroutine too
+        self.func = func
+        self.period = period
+        self.counter = counter
+        self.deadline = time.time() + period
+
+
+class EngineMixin(object):
+    __slots__ = ['devices', 'timers', 'subscribers', 'msg_filter', '_attributesChange', 'network', 'msg_factory']
 
-    def __init__(self,address,port,hops,key):
-        self.devices = []                        # list of devices / use (un)register_devices()
-        self.timers = []                         # functions to call periodic
-        self.subscribers = []                    # message receive workflow
-        self.msg_filter = None                  # message filter
+    def __init__(self, address: str, port: int, hops: int, key: bytes):
+        self.devices:list[Device] = []  # list of devices / use (un)register_devices()
+        self.timers: list[Timer] = []  # functions to call periodic
+        self.subscribers: list[SubFuncT] = []  # message receive workflow
+        self.msg_filter = None  # message filter
 
-        self._attributesChange = []              # list of XAALAttributes instances
+        self._attributesChange = []  # list of XAALAttributes instances
 
         # network connector
         self.network = None
@@ -49,21 +73,21 @@ class EngineMixin(object):
     #####################################################
     # Devices management
     #####################################################
-    def add_device(self, dev):
-        """register a new device """
+    def add_device(self, dev: 'Device'):
+        """register a new device"""
         if dev not in self.devices:
             self.devices.append(dev)
             dev.engine = self
         if self.is_running():
             self.send_alive(dev)
 
-    def add_devices(self, devs):
+    def add_devices(self, devs: List['Device']):
         """register new devices"""
         for dev in devs:
             self.add_device(dev)
 
-    def remove_device(self, dev):
-        """unregister a device """
+    def remove_device(self, dev: 'Device'):
+        """unregister a device"""
         dev.engine = None
         # Remove dev from devices list
         self.devices.remove(dev)
@@ -72,54 +96,53 @@ class EngineMixin(object):
     # xAAL messages Tx handling
     #####################################################
     # Fifo for msg to send
-    def queue_msg(self, msg):
+    def queue_msg(self, msg: bytes):
         logger.critical("To be implemented queue_msg: %s", msg)
 
-    def send_request(self,dev,targets,action,body = None):
+    def send_request(self, dev: 'Device', targets: list, action: str, body: Optional[dict] = None):
         """queue a new request"""
         msg = self.msg_factory.build_msg(dev, targets, MessageType.REQUEST, action, body)
         self.queue_msg(msg)
 
-    def send_reply(self, dev, targets, action, body=None):
+    def send_reply(self, dev: 'Device', targets: list, action: str, body: Optional[dict] = None):
         """queue a new reply"""
         msg = self.msg_factory.build_msg(dev, targets, MessageType.REPLY, action, body)
         self.queue_msg(msg)
 
-    def send_error(self, dev, errcode, description=None):
+    def send_error(self, dev: 'Device', errcode: int, description: Optional[str] = None):
         """queue a error message"""
         msg = self.msg_factory.build_error_msg(dev, errcode, description)
         self.queue_msg(msg)
 
-    def send_get_description(self, dev, targets):
+    def send_get_description(self, dev: 'Device', targets: list):
         """queue a get_description request"""
         self.send_request(dev, targets, MessageAction.GET_DESCRIPTION.value)
 
-    def send_get_attributes(self, dev, targets):
+    def send_get_attributes(self, dev: 'Device', targets: list):
         """queue a get_attributes request"""
         self.send_request(dev, targets, MessageAction.GET_ATTRIBUTES.value)
 
-    def send_notification(self, dev, action, body=None):
+    def send_notification(self, dev: 'Device', action: str, body: Optional[dict] = None):
         """queue a notificaton"""
-        msg = self.msg_factory.build_msg(dev, [], MessageType.NOTIFY, action,body)
+        msg = self.msg_factory.build_msg(dev, [], MessageType.NOTIFY, action, body)
         self.queue_msg(msg)
 
-    def send_alive(self, dev):
+    def send_alive(self, dev: 'Device'):
         """Send a Alive message for a given device"""
         timeout = dev.get_timeout()
         msg = self.msg_factory.build_alive_for(dev, timeout)
         self.queue_msg(msg)
         dev.update_alive()
 
-    def send_is_alive(self, dev, targets=[ALIVE_ADDR,], dev_types=["any.any",]):
+    def send_is_alive(self, dev: 'Device', targets: list = [ALIVE_ADDR,], dev_types: list = ["any.any", ] ):
         """Send a is_alive message, w/ dev_types filtering"""
         body = {'dev_types': dev_types}
-        self.send_request(dev,targets, MessageAction.IS_ALIVE.value, body)
-
+        self.send_request(dev, targets, MessageAction.IS_ALIVE.value, body)
 
     #####################################################
     # Messages filtering
     #####################################################
-    def enable_msg_filter(self, func=None):
+    def enable_msg_filter(self, func: Optional[Callable[['Message'], bool]] = None):
         """enable message filter"""
         self.msg_filter = func or self.default_msg_filter
 
@@ -127,7 +150,7 @@ class EngineMixin(object):
         """disable message filter"""
         self.msg_filter = None
 
-    def default_msg_filter(self, msg):
+    def default_msg_filter(self, msg: 'Message'):
         """
         Filter messages:
         - check if message has alive request address
@@ -150,17 +173,17 @@ class EngineMixin(object):
         """Periodic sending alive messages"""
         now = time.time()
         for dev in self.devices:
-            if dev.next_alive < now :
+            if dev.next_alive < now:
                 self.send_alive(dev)
 
     #####################################################
     # xAAL attributes changes
     #####################################################
-    def add_attributes_change(self, attr):
+    def add_attributes_change(self, attr: 'Attribute'):
         """add a new attribute change to the list"""
         self._attributesChange.append(attr)
 
-    def get_attributes_change(self):
+    def get_attributes_change(self) -> List['Attribute']:
         """return the pending attributes changes list"""
         return self._attributesChange
 
@@ -180,17 +203,18 @@ class EngineMixin(object):
     #####################################################
     # xAAL messages subscribers
     #####################################################
-    def subscribe(self,func):
+    def subscribe(self, func: SubFuncT):
+        # func should be a Callable[[Message],None], but it can be a coroutine too
         self.subscribers.append(func)
 
-    def unsubscribe(self,func):
+    def unsubscribe(self, func: SubFuncT):
         self.subscribers.remove(func)
 
     #####################################################
     # timers
     #####################################################
-    def add_timer(self, func, period,counter=-1):
-        """ 
+    def add_timer(self, func: FuncT, period: int, counter: int = -1):
+        """
         func: function to call
         period: period in second
         counter: number of repeat, -1 => always
@@ -201,7 +225,7 @@ class EngineMixin(object):
         self.timers.append(t)
         return t
 
-    def remove_timer(self, timer):
+    def remove_timer(self, timer: Timer):
         """remove a given timer from the list"""
         self.timers.remove(timer)
 
@@ -220,23 +244,15 @@ class EngineMixin(object):
     def run(self):
         logger.critical("To be implemented run")
 
-    def is_running(self):
+    def is_running(self) -> bool:
         logger.critical("To be implemented is_running")
+        return False
 
-#####################################################
-# Timer class
-#####################################################
-class Timer(object):
-    def __init__(self, func, period, counter):
-        self.func = func
-        self.period = period
-        self.counter = counter
-        self.deadline = time.time() + period
 
 #####################################################
 # Usefull functions to Engine developpers
 #####################################################
-def filter_msg_for_devices(msg, devices):
+def filter_msg_for_devices(msg: 'Message', devices: List['Device']) -> List['Device']:
     """
     loop throught the devices, to find which are expected w/ the msg
     - Filter on dev_types for is_alive broadcast request.
@@ -245,28 +261,29 @@ def filter_msg_for_devices(msg, devices):
     results = []
     if msg.is_request_isalive() and (ALIVE_ADDR in msg.targets):
         # if we receive a broadcast is_alive request, we reply
-        # with filtering on dev_tyes. 
+        # with filtering on dev_tyes.
         if 'dev_types' in msg.body.keys():
             dev_types = msg.body['dev_types']
-            if 'any.any' in dev_types:
+            if "any.any" in dev_types:
                 results = devices
             else:
                 for dev in devices:
-                    any_subtype = dev.dev_type.split('.')[0] + '.any'
+                    any_subtype = dev.dev_type.split(".")[0] + ".any"
                     if dev.dev_type in dev_types:
                         results.append(dev)
                     elif any_subtype in dev_types:
                         results.append(dev)
     else:
         # this is a normal request, only filter on device address
-        # note: direct is_alive are treated like normal request 
+        # note: direct is_alive are treated like normal request
         # so dev_types filtering is discarded
         for dev in devices:
             if dev.address in msg.targets:
                 results.append(dev)
     return results
 
-def search_action(msg, device):
+
+def search_action(msg: 'Message', device: 'Device'):
     """
     Extract an action (match with methods) from a msg on the device.
     Return:
@@ -279,6 +296,7 @@ def search_action(msg, device):
     params = {}
     result = None
     if msg.action in methods.keys():
+        assert msg.action
         method = methods[msg.action]
         body_params = None
         if msg.body:
@@ -286,23 +304,22 @@ def search_action(msg, device):
             body_params = msg.body
 
             for k in body_params:
-                temp = '_%s' %k
+                temp = "_%s" % k
                 if temp in method_params:
-                    params.update({temp:body_params[k]})
+                    params.update({temp: body_params[k]})
                 else:
-                    logger.warning("Wrong method parameter [%s] for action %s" %(k, msg.action))
-        result =  (method,params)
+                    logger.warning("Wrong method parameter [%s] for action %s" % (k, msg.action))
+        result = (method, params)
     else:
-        raise XAALError("Method %s not found on device %s" % (msg.action,device))
+        raise XAALError("Method %s not found on device %s" % (msg.action, device))
     return result
 
-def get_args_method(method):
-    """ return the list on arguments for a given python method """
+
+def get_args_method(method: Any) -> List[str]:
+    """return the list on arguments for a given python method"""
     spec = inspect.getfullargspec(method)
     try:
         spec.args.remove('self')
     except Exception:
         pass
     return spec.args
-
-