xaal.legacytools 0.1__tar.gz

xaal_legacytools-0.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: xaal.legacytools
+Version: 0.1
+Summary: xAAL devices tools
+Author-email: Jerome Kerdreux <Jerome.Kerdreux@imt-atlantique.fr>
+License: GPL License
+Keywords: xaal,tools
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/x-rst
+Requires-Dist: xaal.lib

xaal_legacytools-0.1/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "xaal.legacytools"
+version = "0.1"
+description = "xAAL devices tools"
+readme = "README.rst"
+authors = [ { name = "Jerome Kerdreux", email = "Jerome.Kerdreux@imt-atlantique.fr" } ]
+license = { text = "GPL License"}
+classifiers = ["Programming Language :: Python",
+"Topic :: Software Development :: Libraries :: Python Modules"]
+keywords = ["xaal", "tools"]
+dependencies = ["xaal.lib"]
+
+[project.scripts]
+xaal-isalive-legacy = "xaal.legacytools.isalive:main"
+xaal-info-legacy = "xaal.legacytools.info:main"
+xaal-dumper-legacy = "xaal.legacytools.dumper:main"
+xaal-tail-legacy = "xaal.legacytools.tail:main"
+xaal-walker-legacy = "xaal.legacytools.walker:main"
+xaal-keygen-legacy = "xaal.legacytools.keygen:main"
+xaal-log-legacy = "xaal.legacytools.log:main"
+xaal-querydb-legacy = "xaal.legacytools.querydb:main"
+xaal-pkgrun-legacy = "xaal.legacytools.pkgrun:main"
+xaal-uuidgen-legacy = "xaal.legacytools.uuidgen:main"
+xaal-inspector-legacy = "xaal.legacytools.inspector:main"
+
+[tool.setuptools.packages.find]
+include = ["xaal.legacytools"]

xaal_legacytools-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xaal_legacytools-0.1/xaal/legacytools/__init__.py

@@ -0,0 +1 @@
+

xaal_legacytools-0.1/xaal/legacytools/ansi2.py

@@ -0,0 +1,113 @@
+'''
+    Set ANSI Terminal Color and Attributes.
+'''
+from sys import stdout
+
+esc = '%s['%chr(27)
+reset = '%s0m'%esc
+format = '1;%dm'
+fgoffset, bgoffset = 30, 40
+for k, v in dict(
+    attrs = 'none bold faint italic underline blink fast reverse concealed',
+    colors = 'grey red green yellow blue magenta cyan white'
+).items(): globals()[k]=dict((s,i) for i,s in enumerate(v.split()))
+
+def term(arg=None, sep=' ', end='\n'):
+    '''
+        "arg" is a string or None
+        if "arg" is None : the terminal is reset to his default values.
+        if "arg" is a string it must contain "sep" separated values.
+        if args are found in globals "attrs" or "colors", or start with "@" \
+    they are interpreted as ANSI commands else they are output as text.
+        colors, if any, must be first (foreground first then background)
+        you can not specify a background color alone ; \
+    if you specify only one color, it will be the foreground one.
+        @* commands handle the screen and the cursor :
+            @x;y : go to xy
+            @    : go to 1;1
+            @@   : clear screen and go to 1;1
+
+        examples:
+    term('red')                  : set red as the foreground color
+    term('red blue')             : red on blue
+    term('red blink')            : blinking red
+    term()                       : restore terminal default values
+    term('reverse')              : swap default colors
+    term('cyan blue reverse')    : blue on cyan <=> term('blue cyan)
+    term('red reverse')          : a way to set up the background only
+    term('red reverse blink')    : you can specify any combinaison of \
+            attributes in any order with or without colors
+    term('blink Python')         : output a blinking 'Python'
+    term('@@ hello')             : clear the screen and print 'hello' at 1;1
+    '''
+    cmd, txt = [reset], []
+    if arg:
+        arglist=arg.split(sep)
+        for offset in (fgoffset, bgoffset):
+            if arglist and arglist[0] in colors:
+                cmd.append(format % (colors[arglist.pop(0)]+offset))
+        for a in arglist:
+            c=format % attrs[a] if a in attrs else None
+            if c and c not in cmd:
+                cmd.append(c)
+            else:
+                if a.startswith('@'):
+                    a=a[1:]
+                    if a=='@':
+                        cmd.append('2J')
+                        cmd.append('H')
+                    else:
+                        cmd.append('%sH'%a)
+                else:
+                    txt.append(a)
+    if txt and end: txt[-1]+=end
+    # JKX debug
+    #print cmd
+    stdout.write(esc.join(cmd)+sep.join(txt))
+
+if __name__ == '__main__':
+
+    print()
+    term('@@ reverse blink')
+    print('reverse blink  default colors at 1;1 on a cleared screen')
+    term('red')
+    print('red')
+    term('red blue')
+    print('red blue')
+    term('yellow blink')
+    print('yellow blink')
+    term('default')
+    term('cyan blue cyan blue')
+    term('cyan blue reverse cyan blue reverse')
+    term('blue cyan blue cyan')
+    term('red reverse red reverse')
+    term('yellow red yellow on red 1')
+    term('yellow,red,yellow on red 2', sep=',')
+    print('yellow on red 3')
+    print()
+    for bg in colors:
+        term(bg.title().center(8), sep='.', end='')
+        for fg in colors:
+            att=[fg, bg]
+            if fg==bg: att.append('blink')
+            att.append(fg.center(8))
+            term(','.join(att), sep=',', end='')
+        print()
+    print()
+    for att in attrs:
+        term('%s,%s' % (att, att.title().center(10)), sep=',', end='')
+    print()
+    from time import sleep, strftime, gmtime
+    colist='grey blue cyan white cyan blue'.split()
+    while True:
+        try:
+            for c in colist:
+                sleep(.1)
+                term('%s @28;33 hit ctrl-c to quit' % c)
+            term('yellow @6;66 %s' % strftime('%H:%M:%S', gmtime()))
+        except KeyboardInterrupt:
+            break
+        except:
+            raise
+    term('@30;1')
+    print()

xaal_legacytools-0.1/xaal/legacytools/dumper.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+#
+#  Copyright 2014 Jérôme Colin, Jérôme Kerdreux, Telecom Bretagne.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program 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 General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+from xaal.lib import Engine,helpers
+
+helpers.set_console_title("xaal-dumper")
+
+def display(msg):
+    msg.dump()
+
+def main():
+    try:
+        eng = Engine()
+        eng.subscribe(display)
+        eng.disable_msg_filter()
+        eng.run()
+    except KeyboardInterrupt:
+        print("Bye Bye")
+
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/info.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+
+#
+#  Copyright 2016  Jérôme Kerdreux, IMT Atlantique.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program 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 General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+from xaal.lib import Engine, Device
+from xaal.lib import tools
+
+import sys
+import time
+import pprint
+
+from .ansi2 import term
+
+def usage():
+    print("xaal-info xxxx-xxxx-xxxx : display information about a given device")
+
+
+class InfoDumper:
+
+    def __init__(self,engine):
+        self.eng = engine
+        # new fake device
+        addr = tools.get_random_uuid()
+        dev = Device("cli.experimental",addr)
+        dev.vendor_id = "IHSEV"
+        dev.product_id = "xAAL InfoDumper"
+        self.eng.add_device(dev)
+        self.eng.subscribe(self.parse_answer)
+        print(f"xAAL Info dumper [{addr}]")
+        self.dev = dev
+
+    def query(self,addr):
+        """ send getDescription & getAttributes and wait for reply"""
+
+        self.target = addr
+        self.msgCnt = 0
+        self.timer = 0
+
+        self.eng.send_get_description(self.dev,[addr,])
+        self.eng.send_get_attributes(self.dev,[addr,])
+
+        term('cyan')
+        print("** Device : [%s]" % self.target)
+        term()
+
+        while 1:
+            self.eng.loop()
+            if self.timer > 30:
+                print("TimeOut...")
+                break
+            if self.msgCnt > 1:break
+            self.timer += 1
+        print('\n')
+
+    def parse_answer(self,msg):
+        """ message parser """
+        if msg.is_reply():
+            if self.dev.address in msg.targets:
+                if self.target == msg.source:
+                    if msg.is_get_attribute_reply():
+                        print("== Attributes =====")
+
+                    if msg.is_get_description_reply():
+                        print("== Description ====")
+
+                    pprint.pprint(msg.body)
+                    self.msgCnt += 1
+
+
+def main():
+    if len(sys.argv) == 2:
+        addr = tools.get_uuid(sys.argv[1])
+        if addr:
+            t0 = time.time()
+            eng = Engine()
+            eng.start()
+            dev = InfoDumper(eng)
+            dev.query(addr)
+            print("Time : %0.3f sec" % (time.time() -t0))
+        else:
+            print("Invalid addr")
+
+    else:
+        usage()
+
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/inspector.py

@@ -0,0 +1,82 @@
+from xaal.lib import NetworkConnector,config,cbor,core
+
+class ParseError(Exception):pass
+
+def incr(value,max_value,increment=1):
+    tmp = value + increment
+    if tmp > max_value:
+        raise ParseError("Unable to go forward, issue w/ packet lenght ?")
+    return tmp
+
+def hexdump(data):
+    print("HEX:",end="")
+    for k in data:
+        print("0x%x" % k,end=", ")
+
+def parse(data):
+    i = 0
+    size = len(data)
+
+    print("========= Headers ========")
+    header_size = data[i]
+    if header_size != 0x85:
+        raise ParseError("Wrong array in header: 0x%x" % header_size)
+    print("Array w/ size=5 (0x85) : 0x%x" %header_size)
+
+    i = incr(i,size)
+    ver = data[i]
+    if ver != 7:
+        raise ParseError("Wrong packet version: 0x%x" % ver)
+    print("Version: 0%x" % ver)
+
+    i = incr(i,size)
+    ts0_size = data[i]
+    if ts0_size not in [0x1a,0x1b]:
+        raise ParseError("Wrong timestamp part0 size: 0x%x" % ts0_size)
+    print("TS0 size (0x1a or 0x1b): 0x%x" % ts0_size )
+    if ts0_size == 0x1a:
+        i=incr(i,size,5)
+        ts0 = list(data[i-4:i])
+        print("TS0: ",end="")
+        hexdump(ts0)
+        print("=> %s" % cbor.loads(bytes(data[i-5:i])))
+
+    if ts0_size == 0x1b:
+        i=incr(i,size,9)
+        ts0 = list(data[i-8:i])
+        print("TS0: ",end="")
+        hexdump(ts0)
+        print("=> %s" % cbor.loads(bytes(data[i-9:i])))
+
+    ts1_size = data[i]
+    if ts1_size != 0x1a:
+        raise ParseError("Wrong timestamp part1 size: 0x%x" % ts1_size)
+    print("TS1 size (0x1a): 0x%x" % ts0_size )
+    i = incr(i,size,5)
+    ts1 = list(data[i-4:i])
+    print("TS1: ",end="")
+    hexdump(ts1)
+    print("=> %s" % cbor.loads(bytes(data[i-5:i])))
+
+    target_size = data[i]
+    hexdump(data[i:i+10])
+    #print("0x%x" % target_size)
+
+    print()
+
+def main():
+    nc = NetworkConnector(config.address,config.port,config.hops)
+    while 1:
+        data = nc.get_data()
+        if data:
+            try:
+                parse(data)
+            except ParseError as e:
+                print("ERROR ==> %s" % e)
+
+if __name__ == '__main__':
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("Bye...")
+    

xaal_legacytools-0.1/xaal/legacytools/isalive.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+
+#
+#  Copyright 2014 Jérôme Kerdreux, Telecom Bretagne.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program 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 General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from xaal.lib import Engine, Device, tools, config,helpers
+
+import sys
+import time
+import logging
+
+helpers.setup_console_logger()
+logger = logging.getLogger("xaal-isalive")
+
+class Scanner:
+
+    def __init__(self,engine):
+        self.eng = engine
+        # new fake device
+        self.dev = Device("cli.experimental",tools.get_random_uuid())
+        self.eng.add_device(self.dev)
+        self.eng.subscribe(self.parse_answer)
+
+    def query(self,dev_type):
+        if not tools.is_valid_dev_type(dev_type):
+            logger.warning("dev_type not valid [%s]" % dev_type)
+            return
+        self.dev_type = dev_type
+        self.seen = []
+
+        logger.info("[%s] searching [%s]" % (self.dev.address,self.dev_type))
+        self.eng.send_is_alive(self.dev,dev_types=[self.dev_type,])
+
+        print("="*70)
+        self.loop()
+        print("="*70)
+        print("Found %d devices" % len(self.seen))
+
+    def loop(self):
+        t0 = time.time()
+        while 1:
+            self.eng.loop()
+            if time.time() > (t0 + 2):
+                break
+
+    def parse_answer(self,msg):
+        if msg.is_alive():
+            # hidding myself
+            if msg.source == self.dev.address:
+                return
+            #it is really for us ?
+            if self.dev_type != 'any.any':
+                (target_dev_type,target_devsubtype) = self.dev_type.split('.')
+                (msg_dev_type,msg_devsubtype) = msg.dev_type.split('.')
+                if msg_dev_type != target_dev_type:
+                    return
+                if target_devsubtype != 'any' and target_devsubtype != msg_devsubtype:
+                    return
+            if msg.source in self.seen:
+                return
+            # everything is Ok :)
+            print("%s : %s" % (msg.source,msg.dev_type))
+            self.seen.append(msg.source)
+
+
+
+def run():
+    """ run the isalive scanner from cmdline"""
+    eng = Engine()
+    eng.disable_msg_filter()
+
+    scan = Scanner(eng)
+    eng.start()
+    dev_type = 'any.any'
+    if len(sys.argv) == 2:
+        dev_type = sys.argv[1]
+    scan.query(dev_type)
+
+
+def search(engine,dev_type='any.any'):
+    """ send request and return list of xaal-addr"""
+    scan = Scanner(engine)
+    scan.query(dev_type)
+    return scan.seen
+
+def main():
+    try:
+        run()
+    except KeyboardInterrupt:
+        print("Bye bye")
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/keygen.py

@@ -0,0 +1,22 @@
+""" Tool to build a key pass for xAAL config file"""
+
+from __future__ import print_function
+
+from six.moves import input
+
+
+from xaal.lib import tools
+import binascii
+
+def main():
+    try:
+        temp = input("Please enter your passphrase: ")
+        key  = tools.pass2key(temp)
+        print("Cut & Paste this key in your xAAL config-file")
+        print("key=%s"% binascii.hexlify(key).decode('utf-8'))
+    except KeyboardInterrupt:
+        print("Bye Bye..")
+        
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/log.py

@@ -0,0 +1,25 @@
+""" dumb script that display attributes change the xAAL bus"""
+
+from xaal.lib import Engine,helpers,Message
+import time
+
+helpers.set_console_title("xaal-log")
+
+def print_evt(msg):
+    if msg.is_alive():
+        return
+    if msg.is_notify():
+        print("%s %s %s %s %s" % (time.ctime(),msg.source,msg.dev_type,msg.action,msg.body))
+
+
+def main():
+    try:
+        eng = Engine()
+        eng.disable_msg_filter()
+        eng.subscribe(print_evt)
+        eng.run()
+    except KeyboardInterrupt:
+        print("ByeBye..")
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/pkgrun.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+try:
+    from gevent import monkey;monkey.patch_all(thread=False)
+except ModuleNotFoundError:
+    pass
+
+import sys
+import importlib
+
+
+from xaal.lib import helpers
+from xaal.lib import AsyncEngine as Engine
+import logging
+
+
+MY_NAME = "xaal-pkgrun"
+logger = logging.getLogger(MY_NAME)
+
+
+def load_pkgs(eng):
+    for k in sys.argv[1:]:
+        xaal_mod = 'xaal.' + k
+        try:
+            mod = importlib.import_module(xaal_mod)
+        except ModuleNotFoundError:
+            logger.critical("Unable to load module: %s" %xaal_mod )
+            continue
+    
+        if hasattr(mod,'setup') == False:
+            logger.critical("Unable to setup %s" % xaal_mod)
+            continue
+        mod.setup(eng)
+
+def run():
+    # some init stuffs
+    helpers.setup_console_logger()
+    #helpers.setup_file_logger(MY_NAME) 
+    # Start the engine
+    eng = Engine()
+    eng.start()
+    load_pkgs(eng)
+    eng.run()    
+
+def main():
+    try:
+        run()
+    except KeyboardInterrupt:
+        print("Byebye")
+
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/querydb.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+
+#
+#  Copyright 2016  Jérôme Kerdreux, IMT Atlantique.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program 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 General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+from xaal.lib import Engine, Device, MessageType
+from xaal.lib import tools
+from . import isalive
+
+
+import sys
+import json
+import time
+
+from .ansi2 import term
+
+def usage():
+    print("xaal-querydb xxxx-xxxx-xxxx : display metadata for a given device")
+
+
+class QueryDB:
+
+    def __init__(self,engine,db_servers):
+        self.eng = engine
+        self.db_servers = db_servers
+        # new fake device
+        self.addr = tools.get_random_uuid()
+        self.dev = Device("cli.experimental",self.addr)
+        self.eng.add_device(self.dev)
+        self.eng.add_rx_handler(self.parse_answer)
+        
+        print("xAAL DB query [%s]" % self.addr)
+
+
+    def query(self,addr):
+        self.timer = 0
+
+        mf = self.eng.msg_factory
+        body = {'device': addr,}
+        msg = mf.build_msg(self.dev,self.db_servers, MessageType.REQUEST,'get_keys_values',body)
+        self.eng.queue_msg(msg)
+
+        while 1:
+            self.eng.loop()
+            if self.timer > 40:
+                print("TimeOut...")
+                break
+            self.timer += 1
+        print('\n')
+
+    def parse_answer(self,msg):
+        """ message parser """
+        if msg.is_reply():
+            if (self.addr in msg.targets) and (msg.action == 'get_keys_values'):
+                term('yellow')
+                print("%s => " % msg.source,end='')
+                print(msg.body)
+                term()
+
+
+def main():
+    if len(sys.argv) == 2:
+        addr = tools.get_uuid(sys.argv[1])
+        if tools.is_valid_address(addr):
+            t0 = time.time()
+            eng = Engine()
+            eng.start()
+            db_servers = isalive.search(eng,'metadatadb.basic')
+            if len(db_servers) == 0:
+                print("No metadb server found")
+                return
+            dev = QueryDB(eng,db_servers)
+            dev.query(addr)
+            print("Time : %0.3f sec" % (time.time() -t0))
+        else:
+            print("Invalid addr")
+
+    else:
+        usage()
+
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/tail.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+
+#
+#  Copyright 2014 Jérôme Colin, Jérôme Kerdreux, Telecom Bretagne.
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  This program 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 General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program. If not, see <http://www.gnu.org/licenses/>.
+#
+
+from xaal.lib import Engine,MessageType
+from xaal.lib import tools
+
+from .ansi2 import term
+import sys
+import shutil
+
+level = 0
+
+HIDE_ACTION=['get_attributes','get_description','get_keys_values','is_alive']
+
+
+def type_to_string(mtype):
+    tmp = str(MessageType(mtype))
+    return tmp.split('.')[-1]
+
+
+def display(msg):
+    term('yellow')
+
+    if (msg.action in HIDE_ACTION and level==2):
+        return
+        
+    if msg.is_reply():
+        if level > 2: return
+        term('red')
+
+    if msg.is_request():
+        if level > 3: return
+        term('green')
+
+    if msg.is_notify():
+        if msg.is_alive():
+            if level > 0: return
+            term('grey')
+        if msg.is_attributes_change():
+            term('cyan')
+
+    targets = [tools.reduce_addr(addr) for addr in msg.targets]
+    tmp = shutil.get_terminal_size()[0] - (8 + 20 + 36 + 20 + 16 + 9)
+    if tmp < 50:
+        tmp = 50
+    BODY_FORMAT = '%-50.'+str(tmp)+'s'
+    FORMAT = '%-8.08s=> %-18.18s %-36.36s (%-20.20s) %-16.16s '+BODY_FORMAT
+    res = FORMAT % (type_to_string(msg.msg_type),msg.action,msg.source,msg.dev_type,targets,msg.body)
+    print(res)
+
+def usage():
+    print("%s : monitor xAAL network w/ tail format" % sys.argv[0])
+    print("  usage : %s log-level" % sys.argv[0])
+    print("    level=0 => display all messages")
+    print("    level=1 => hide alive messages")
+    print("    level=2 => hide xAAL actions messages")
+    print("    level=3 => hide reply messages")
+    print("    level=4 => only notifications (attributesChange)")
+
+
+def main():
+    global level
+    if len(sys.argv) == 2:
+        level = int(sys.argv[1])
+
+        eng = Engine()
+        eng.disable_msg_filter()
+        eng.subscribe(display)
+
+        eng.start()
+        term('@@')
+        FORMAT = '%-8.08s=> %-18.18s %-36.36s (%-20.20s) %-16.16s %-50.50s'        
+        print(FORMAT % ('type','action','source','dev_type','targets','body'))
+        try:
+            eng.run()
+        except KeyboardInterrupt:
+            pass
+    else:
+        usage()
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/uuidgen.py

@@ -0,0 +1,25 @@
+from xaal.lib import tools
+import sys
+
+
+def main():
+    uuid = None
+    if len(sys.argv) > 1:
+        value = sys.argv[1]
+        uuid = tools.get_uuid(value)
+    if uuid == None:
+        uuid=tools.get_random_uuid()
+    print("TXT: %s" % uuid)
+
+    print("HEX: ",end="")
+    for b in uuid.bytes:
+        print("0x%x" % b,end=',')
+    print()
+
+    print("INT: ",end="")
+    for b in uuid.bytes:
+        print("%d" % b,end=',')
+    print()
+
+if __name__ == '__main__':
+    main()

xaal_legacytools-0.1/xaal/legacytools/walker.py

@@ -0,0 +1,35 @@
+"""
+Little helper script to walk in device list
+It first send an isAlive message and then
+gather information on each device
+"""
+
+import sys
+import time
+
+import xaal.lib
+
+
+from . import info
+from . import isalive
+
+
+def main():
+    """ search for alive devices and gather informations about this device"""
+
+    eng = xaal.lib.Engine()
+    eng.disable_msg_filter()
+    eng.start()
+    devtype = 'any.any'
+    if len(sys.argv) == 2:
+        devtype = sys.argv[1]
+    devs = isalive.search(eng,devtype)
+    print()
+    dumper = info.InfoDumper(eng)
+    t0 = time.time()
+    for k in devs:
+        dumper.query(k)
+    print("Time : %0.3f sec (%d devices)" % (time.time() -t0,len(devs)))
+
+if __name__=='__main__':
+    main()

xaal_legacytools-0.1/xaal.legacytools.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: xaal.legacytools
+Version: 0.1
+Summary: xAAL devices tools
+Author-email: Jerome Kerdreux <Jerome.Kerdreux@imt-atlantique.fr>
+License: GPL License
+Keywords: xaal,tools
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Description-Content-Type: text/x-rst
+Requires-Dist: xaal.lib

xaal_legacytools-0.1/xaal.legacytools.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.rst
+pyproject.toml
+xaal.legacytools.egg-info/PKG-INFO
+xaal.legacytools.egg-info/SOURCES.txt
+xaal.legacytools.egg-info/dependency_links.txt
+xaal.legacytools.egg-info/entry_points.txt
+xaal.legacytools.egg-info/requires.txt
+xaal.legacytools.egg-info/top_level.txt
+xaal/legacytools/__init__.py
+xaal/legacytools/ansi2.py
+xaal/legacytools/dumper.py
+xaal/legacytools/info.py
+xaal/legacytools/inspector.py
+xaal/legacytools/isalive.py
+xaal/legacytools/keygen.py
+xaal/legacytools/log.py
+xaal/legacytools/pkgrun.py
+xaal/legacytools/querydb.py
+xaal/legacytools/tail.py
+xaal/legacytools/uuidgen.py
+xaal/legacytools/walker.py

xaal_legacytools-0.1/xaal.legacytools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xaal_legacytools-0.1/xaal.legacytools.egg-info/entry_points.txt

@@ -0,0 +1,12 @@
+[console_scripts]
+xaal-dumper-legacy = xaal.legacytools.dumper:main
+xaal-info-legacy = xaal.legacytools.info:main
+xaal-inspector-legacy = xaal.legacytools.inspector:main
+xaal-isalive-legacy = xaal.legacytools.isalive:main
+xaal-keygen-legacy = xaal.legacytools.keygen:main
+xaal-log-legacy = xaal.legacytools.log:main
+xaal-pkgrun-legacy = xaal.legacytools.pkgrun:main
+xaal-querydb-legacy = xaal.legacytools.querydb:main
+xaal-tail-legacy = xaal.legacytools.tail:main
+xaal-uuidgen-legacy = xaal.legacytools.uuidgen:main
+xaal-walker-legacy = xaal.legacytools.walker:main

xaal_legacytools-0.1/xaal.legacytools.egg-info/requires.txt

@@ -0,0 +1 @@
+xaal.lib

xaal_legacytools-0.1/xaal.legacytools.egg-info/top_level.txt

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