xaal.lib 0.7.2__py3-none-any.whl

xaal/lib/network.py

@@ -0,0 +1,100 @@
+#
+#  Copyright 2014, Jérôme Colin, Jérôme Kerdreux, Philippe Tanguy,
+#  Telecom Bretagne.
+#
+#  This file is part of xAAL.
+#
+#  xAAL is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  xAAL is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with xAAL. If not, see <http://www.gnu.org/licenses/>.
+#
+
+import socket
+import struct
+import select
+import logging
+
+logger = logging.getLogger(__name__)
+
+import time
+from enum import Enum
+
+class NetworkState(Enum):
+    disconnected = 0
+    connected    = 1
+
+
+class NetworkConnector(object):
+    UDP_MAX_SIZE = 65507
+
+    def __init__(self, addr, port, hops,bind_addr='0.0.0.0'):
+        self.addr = addr
+        self.port = port
+        self.hops = hops
+        self.bind_addr = bind_addr
+        self.state = NetworkState.disconnected
+
+    def connect(self):
+        try:
+            self.__connect()
+        except Exception as e:
+            self.network_error(e)
+
+    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.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+        # #formac os ???
+        #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)
+        self.state = NetworkState.connected
+
+    def disconnect(self):
+        logger.info("Disconnecting from the bus")
+        self.state = NetworkState.disconnected
+        self.__sock.close()
+
+    def is_connected(self):
+        return self.state == NetworkState.connected
+
+    def receive(self):
+        packt = self.__sock.recv(self.UDP_MAX_SIZE)
+        return packt
+
+    def __get_data(self):
+        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()
+        try:
+            return self.__get_data()
+        except Exception as e:
+            self.network_error(e)
+
+    def send(self,data):
+        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):
+        self.disconnect()
+        logger.info("Network error, reconnect..%s" % msg)
+        time.sleep(5)

xaal/lib/test.py

@@ -0,0 +1,140 @@
+
+
+import xaal.lib
+from xaal.lib import tools
+
+
+import logging
+
+
+ADDR="b8bec7ca-f955-11e6-9031-82ed25e6aaaa"        
+ADDR=tools.get_random_uuid()      
+
+def dump_hex(name,data):
+    print("%s : " % name,end='=')
+    for k in data:
+        if type(k) == int:
+            print("%x"%k,end=' ')
+        else:
+            print("%x"%ord(k),end=' ')
+    print()
+
+def test_pysodium():
+    from xaal.lib import messages
+    import pysodium
+
+    payload = "FooBar".encode("utf-8")
+    ad = '[]'
+
+    data  = messages.build_timestamp()
+    nonce = messages.build_nonce(data)
+    key = tools.pass2key("My Friend Goo")
+    
+    dump_hex("Payload",payload)
+    dump_hex("Key",key)
+
+    ciph  = pysodium.crypto_aead_chacha20poly1305_encrypt(payload, ad, nonce, key)
+    dump_hex("Ciph",ciph)
+    
+    pjson = pysodium.crypto_aead_chacha20poly1305_decrypt(ciph, ad, nonce, key)
+    print(pjson)
+
+    
+def test_device():
+    from xaal.lib.devices import Device
+    addr = ADDR
+    dev = Device("foo.basic",addr)
+    dev.vendor_id = "ACME"
+    dev.url="http://acmefactory.blogspot.fr/"
+    dev.hw_id = "0x201"
+    print(dev.getDescription())
+    return dev
+
+def test_msg():
+    from xaal.lib.messages import Message
+    msg = Message()
+    addr = ADDR
+    msg.targets = [addr,]
+    msg.dump()
+
+def test_encode():
+    from xaal.lib.messages import MessageFactory
+    key = tools.pass2key("FooBar")
+    factory = MessageFactory(key)
+    m2 = factory.build_msg()
+    print(factory.decode_msg(m2))
+
+def test_log():
+    logger = logging.getLogger(__name__)
+    logger.info("This is an INFO msg")
+    logger.debug("This is an DEBUG msg")
+    
+
+def test_engine():
+    from xaal.lib.core import Engine
+    engine = Engine()
+    engine.run()
+
+def test_alive():
+    addr = ADDR
+    dev = xaal.lib.Device("test.basic",addr)
+    eng = xaal.lib.Engine()
+    eng.add_devices([dev,])
+    eng.run()
+
+def test_crypto_decoding_error():
+    addr = ADDR
+    dev = xaal.lib.Device("test.basic",addr)
+    eng = xaal.lib.Engine()
+    eng.add_devices([dev,])
+    eng.msg_factory.cipher_key = tools.pass2key("FakeKey")
+    eng.start()
+    eng.loop()
+
+
+def test_attr():
+    dev = xaal.lib.Device("test.basic",ADDR)
+    dev.url = "http://linux.org"
+    dev.vendor_id = "ACME"
+    dev.product_id = "Full Fake Device"
+    dev.info = "FooBar"
+    dev.hw_id = "ffd0001"
+    #dev.alive_period = 100
+
+    attr0 = dev.new_attribute("attr0",10)
+    attr1 = dev.new_attribute("attr1",False)
+
+    eng = xaal.lib.Engine()
+    eng.add_devices([dev,])
+
+    def update():
+        attr0.value = attr0.value + 1
+
+    eng.add_timer(update,60)
+    
+    #eng.loop()
+    eng.run()
+    
+
+    
+def run():
+
+    logger = tools.get_logger(__name__,logging.DEBUG,"%s.log" % __name__)
+    #test_pysodium()
+    #test_device()
+    #test_msg()
+    #test_encode()
+    #test_log()
+    #test_alive()
+    #test_crypto_decoding_error()
+    test_attr()
+    
+    
+
+if __name__ == '__main__':
+    try:
+        run()
+    except KeyboardInterrupt:
+        print("Bye bye...")
+        
+    

xaal/lib/tools.py

@@ -0,0 +1,130 @@
+#
+#  Copyright 2014, Jérôme Colin, Jérôme Kerdreux, Philippe Tanguy,
+#  Telecom Bretagne.
+#
+#  This file is part of xAAL.
+#
+#  xAAL is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  xAAL is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with xAAL. If not, see <http://www.gnu.org/licenses/>.
+#
+
+import os
+import re
+
+import pysodium
+
+import sys
+import functools
+from configobj import ConfigObj
+
+from . import config
+from .bindings import UUID
+
+XAAL_DEVTYPE_PATTERN = '^[a-zA-Z][a-zA-Z0-9_-]*\.[a-zA-Z][a-zA-Z0-9_-]*$'
+
+def get_cfg_filename(name, cfg_dir=config.conf_dir):
+    if name.startswith('xaal.'):
+        name = name[5:]
+    filename = '%s.ini' % name
+    if not os.path.isdir(cfg_dir):
+        print("Your configuration directory doesn't exist: [%s]" % cfg_dir)
+    return os.path.join(cfg_dir, filename)
+        
+def load_cfg_file(filename):
+    """ load .ini file and return it as dict"""
+    if os.path.isfile(filename):
+        return ConfigObj(filename,indent_type='  ',encoding="utf8")
+    return None
+
+def load_cfg(app_name):
+    filename = get_cfg_filename(app_name)
+    return load_cfg_file(filename)
+
+def load_cfg_or_die(app_name):
+    cfg = load_cfg(app_name)
+    if not cfg:
+        print("Unable to load config file %s" % get_cfg_filename(app_name))
+        sys.exit(-1)
+    return cfg
+
+def new_cfg(app_name):
+    filename = get_cfg_filename(app_name)
+    cfg = ConfigObj(filename,indent_type='  ')
+    cfg['config'] = {}
+    cfg['config']['addr']=get_random_uuid().str
+    return cfg
+
+def get_random_uuid():
+    return UUID.random()
+
+def get_random_base_uuid(digit=2):
+    return UUID.random_base(digit)
+
+def get_uuid(val):
+    if isinstance(val,UUID):
+        return val
+    if isinstance(val,str):
+        return str_to_uuid(val)
+    return None
+
+def str_to_uuid(val):
+    """ return an xAAL address for a given string"""
+    try:
+        return UUID(val)
+    except ValueError:
+        return None
+
+def bytes_to_uuid(val):
+    try:
+        return UUID(bytes=val)
+    except ValueError:
+        return None
+
+def is_valid_uuid(val):
+    return isinstance(val,UUID)
+
+def is_valid_address(val):
+    return is_valid_uuid(val)
+
+@functools.lru_cache(maxsize=128)
+def is_valid_dev_type(val):
+    if not isinstance(val,str):
+        return False
+    if re.match(XAAL_DEVTYPE_PATTERN,val):
+       return True
+    return False
+
+def pass2key(passphrase):
+    """Generate key from passphrase using libsodium
+    crypto_pwhash_scryptsalsa208sha256 func
+    salt: buffer of zeros
+    opslimit: crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE
+    memlimit: crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE
+    """
+    buf = passphrase.encode('utf-8')
+    KEY_BYTES = pysodium.crypto_pwhash_scryptsalsa208sha256_SALTBYTES #32 
+    # this should be:
+    # salt = bytes(KEY_BYTES)
+    # but due to bytes() stupid stuff in py2 we need this awfull stuff
+    salt = ('\00' * KEY_BYTES).encode('utf-8')
+    opslimit = pysodium.crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_INTERACTIVE
+    memlimit = pysodium.crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE
+    key = pysodium.crypto_pwhash_scryptsalsa208sha256(KEY_BYTES, buf, salt, opslimit, memlimit)
+    return key
+
+@functools.lru_cache(maxsize=128)
+def reduce_addr(addr):
+    """return a string based addred without all  digits"""
+    tmp = addr.str
+    return tmp[:5] + '..' + tmp[-5:]
+

xaal.lib-0.7.2.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: xaal.lib
+Version: 0.7.2
+Summary: xaal.lib is the official Python stack of xAAL protocol dedicated to home automation systems
+Author-email: Jerome Kerdreux <Jerome.Kerdreux@imt-atlantique.fr>
+License: GPL License
+Keywords: xaal,home-automation
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/x-rst
+Requires-Dist: cbor2 ==5.4.2
+Requires-Dist: pysodium
+Requires-Dist: configobj
+Requires-Dist: coloredlogs
+Requires-Dist: decorator
+Requires-Dist: tabulate
+Requires-Dist: aioconsole
+
+
+xaal.lib
+========
+**xaal.lib** is the official Python stack to develop home-automation devices and gateways
+with the xAAL protocol. For a full description of the protocol check out 
+http://recherche.imt-atlantique.fr/xaal/
+
+
+Dependencies
+~~~~~~~~~~~~
+xaal.lib depends on :
+ * cbor2
+ * pysodium
+ * configobj
+ * coloredlogs
+ * decorator
+ * tabulate
+ * aioconsole
+
+
+Install
+~~~~~~~
+Please refer to the official `full documentation to install the lib in a virtualenv 
+<https://redmine.telecom-bretagne.eu/svn/xaal/code/Python/branches/0.7/README.html>`_
+
+
+Usage
+~~~~~
+The main goal of xaal.lib is to provide an API to easily develop devices & gateways.
+**xaal.lib.Engine send / receive / parse to|from xAAL Bus**.
+
+
+To receive / parse / display incoming xAAL messages, you can simply try something like
+this:
+
+.. code-block:: python
+   
+   from xaal.lib import Engine
+
+   def display(msg):
+       print(msg)
+
+   eng = Engine()
+   eng.subscribe(display)
+   eng.run()
+   
+The Engine will call the display function every time it receive a xAAL message.
+
+Let's take a look at a simple lamp device : 
+
+.. code-block:: python
+   
+   from xaal.lib import Device,Engine,tools
+   
+   # create and configure the lamp device, with a random address
+   dev = Device("lamp.basic", tools.get_random_uuid()) 
+   dev.product_id = 'Dummy Lamp'
+   dev.url  = 'http://www.acme.org'
+   dev.info = 'My fake lamp'
+
+   # add an xAAL attribute 'light'
+   light = dev.new_attribute('light')
+   
+   # declare two device methods ON & OFF
+   def on():
+       light.value = True
+
+   def off():
+       light.value = False
+       
+   dev.add_method('turn_on',on)
+   dev.add_method('turn_off',off)
+
+   # last step, create an engine and register the lamp
+   eng = Engine()
+   eng.add_device(dev)
+   eng.run()
+   
+   
+FAQ
+~~~
+The core engine run forever so how can I use it in webserver, GUI or to develop device
+with IO. The whole API is absolutely not thread safe, so **don't use threads** unless you
+exactly know what's going on. Anyways, you have several options to fix this issue:
+
+* You can use you own loop and periodically call *eng.loop()*
+  for example, you can do something like this:
+  
+  .. code:: python
+     
+     while 1:
+         do_some_stuff()
+         eng.loop()
+
+* You can use a engine timer, to perform some stuff.
+  
+  .. code:: python
+     
+     def read_io():
+         pass
+
+     # call the read_io function every 10 sec
+     eng.add_timer(read_io,10)
+     eng.run()
+
+* Use the **AsyncEngine**. Python version > 3.8 provides async programming with **asyncio** package.
+  *AsyncEngine* use the same API as *Engine*, but it is a **asynchronous** engine. You can use
+  *coroutines* in device methods, timers functions and callbacks. It provides additionals features
+  like the *on_start* and *on_stop* callbacks.
+
+* Use an alternate coroutine lib, you can use **gevent** or **greenlet** for example. Look at 
+  apps/rest for a simple greenlet example. 
+  

xaal.lib-0.7.2.dist-info/RECORD

@@ -0,0 +1,22 @@
+xaal/__init__.py,sha256=jv2YF__bseklT3OWEzlqJ5qE24c4aWd5F4r0TTjOrWQ,65
+xaal/lib/__init__.py,sha256=MMXBicq9vNn6yCzBPcqZfTXk329NEL-qTM95jXUMymE,471
+xaal/lib/__main__.py,sha256=xsVqqoIh3UeJIXxeexSfmGSUP4YxUcibdZExjEzk4lE,30
+xaal/lib/aioengine.py,sha256=3MTG9aGKekVvsWhYaehZqZem6YmPng4UqGfDoRTaC2E,13100
+xaal/lib/aiohelpers.py,sha256=2a310wSXzbg9SGYzrTfcHbaZ8PWEe9rLteDmS2i62kU,1007
+xaal/lib/aionetwork.py,sha256=pH-5kf8o4FHsbvs-oFf5guAgYaEu0aosyTuI3k8xt2M,2484
+xaal/lib/bindings.py,sha256=EkDJJ_iBQbC7UzsjHfoXAjpGSwC613hrIm5ubrkcw4k,1994
+xaal/lib/cbor.py,sha256=hWE-mfwhzYQVZ1-JWyx2vy0Sl96Pv6KV7qaN_nf_DxE,1666
+xaal/lib/config.py,sha256=jNAEXCswWsKrVab3hycupQn4aYt4c61eq628ow_I2ZI,1736
+xaal/lib/core.py,sha256=VfaisNREUse-zMrilJuKf6NLVO9HugL1U_I4M7BFzKQ,10806
+xaal/lib/devices.py,sha256=ZDNVNVmJ26W2atuNkzB7xtYZQAT3dWTrQCvMCDMSVWA,9574
+xaal/lib/engine.py,sha256=p2of6IPQB0It0RNu5fkJHHp615K_2rgzHfuWOpvJ6Is,7539
+xaal/lib/exceptions.py,sha256=ZKDKGlm_F48K_0NlaV1fa0Z-a4ZnOxT7NU8c8MKSJAc,504
+xaal/lib/helpers.py,sha256=mXxVxv7fTV9O9xO1BROhVYBTmdviMl6qx3Il8q1ox8w,2679
+xaal/lib/messages.py,sha256=cLwplLp_0qmlgZi6ByohvLEcmuxpWK7liE5dpqyV9AM,11552
+xaal/lib/network.py,sha256=3HWuQ0afQ-X6_-En2rFeqYJ0Scy5IEHfd0qTldxxCFo,3130
+xaal/lib/test.py,sha256=laVbgG4HtQquxDzixAG-Cka-HO4kpb7YUsLL267mGPU,3006
+xaal/lib/tools.py,sha256=SnXmOkeTd4eTN8yWn-GyCkV5mYiG-MX4hkF39KnogLE,3841
+xaal.lib-0.7.2.dist-info/METADATA,sha256=nOxqYAIqm40VUe4t2-22728LE5yL_PfxRlXjbQaI_X0,3545
+xaal.lib-0.7.2.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+xaal.lib-0.7.2.dist-info/top_level.txt,sha256=UZ2WDkN02ztkh1OrsjrW8Kmj4n3WqC0BQxaEYOYfWa0,5
+xaal.lib-0.7.2.dist-info/RECORD,,

xaal.lib-0.7.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (70.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xaal.lib-0.7.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+xaal