unisi 0.1.0__py3-none-any.whl

unisi/__init__.py

@@ -0,0 +1,7 @@
+from .utils import *
+from .guielements import *
+from .users import User, handle
+from .server import start
+from .tables import *
+from .containers import *
+from .proxy import *

unisi/autotest.py

@@ -0,0 +1,210 @@
+import config, os, logging
+from .utils import *
+from .guielements import * 
+from .containers import Block, Dialog
+from .users import User
+from .common import *
+from jsoncomparison import Compare, NO_DIFF
+
+#setting config variables
+testdir = 'autotest'
+if not hasattr(config, testdir):
+    config.autotest = False
+if not hasattr(config, 'port'):
+    config.port = 8000
+if not hasattr(config, 'pretty_print'):
+    config.pretty_print = False
+if not hasattr(config, 'upload_dir'):
+    config.upload_dir = 'web'
+if not hasattr(config, 'logfile'):
+    config.logfile = None
+if not hasattr(config, 'hot_reload'):
+    config.hot_reload = False
+if not hasattr(config, 'appname'):
+    config.appname = 'Unisi app'
+if not hasattr(config, 'mirror'):
+    config.mirror = False
+
+if not os.path.exists(config.upload_dir):
+    os.makedirs(config.upload_dir)
+
+#start logging 
+format = "%(asctime)s - %(levelname)s - %(message)s"
+logfile = config.logfile
+handlers = [logging.FileHandler(logfile), logging.StreamHandler()] if logfile else []
+logging.basicConfig(level = logging.WARNING, format = format, handlers = handlers)
+
+comparator = Compare().check
+
+def jsonString(obj):
+    pretty = config.pretty_print
+    return toJson(obj, 2 if pretty else 0, pretty)
+
+class Recorder:
+    def __init__(self):
+        self.start(None)
+        
+    def accept(self, msg, response):        
+        if self.ignored_1message:            
+            self.record_buffer.append(f"{jsonString(msg)},\
+                \n{'null' if response is None else jsonString(response)}\n")
+        else: #start for setting screen
+            self.record_buffer.append(jsonString(ArgObject(block = 'root', 
+                element = None, value = User.last_user.screen_module.name)))
+            self.ignored_1message = True    
+
+    def stop_recording(self, _, x):    
+        button.spinner = None
+        button.changed = button_clicked
+        button.tooltip = 'Create autotest'
+        full = len(self.record_buffer) > 1
+        if full:             
+            with open(self.record_file, mode='w') as file:    
+                content = ',\n'.join(self.record_buffer)
+                file.write(f"[\n{content}]")
+        test_name = self.record_file
+        self.record_file = None
+        
+        return Info(f'Test {test_name} is created.', button) if full else\
+            Warning('Nothing to save!',button)
+
+    def start(self,fname):
+        self.record_file = fname
+        self.ignored_1message = False
+        self.record_buffer = []
+
+recorder = Recorder()
+
+def obj2pyjson(obj):
+    return json.loads(jsonpickle.encode(obj,unpicklable=False))
+
+def test(filename, user):
+    filepath = f'{testdir}{divpath}{filename}'
+    file = open(filepath, "r") 
+    data = json.loads(file.read())
+    error = False
+    for message in data:
+        if message is not None and message.get('block'):
+            result = user.result4message(ReceivedMessage(message))
+            response = user.prepare_result(result)
+            user_message = message
+        else:
+            diff = comparator(message, obj2pyjson(response))
+            if diff != NO_DIFF:
+                print(f"\nTest {filename} is failed on message {user_message}:")
+                err = diff.get('_message')
+                if err:
+                    print(f"  {err}")
+                else:
+                    for value in diff.values():
+                        err = value['_message']                        
+                        print(f"  {err}")
+                error = True
+    return not error
+
+test_name = Edit('Name test file', '', focus = True)
+rewrite = Switch('Overwrite existing', False, type = 'check')
+
+def button_clicked(_,__):
+    test_name.value = ''
+    test_name.complete = smart_complete(os.listdir(testdir))
+    return Dialog('Create autotest..', ask_create_test, test_name, rewrite)
+
+def create_test(fname):
+    fname = f'{testdir}{divpath}{fname}'    
+    if os.path.exists(fname) and not rewrite.value:
+        return Warning(f'Test file {fname} already exists!')              
+    
+    button.spinner = True   
+    button.tooltip = 'Stop test recording'
+    button.changed = recorder.stop_recording
+    recorder.start(fname)
+    
+    return Info('Test is recording.. press the same button to stop',button)     
+
+def ask_create_test(_, bname):
+    if bname == 'Ok':            
+        return create_test(test_name.value) if test_name.value else\
+            Warning('Test file name is not defined!')
+
+button = Button('_Add test', button_clicked, right = True,
+    icon='format_list_bulleted_add', tooltip='Create autotest')
+
+def check_block(self):
+    errors = []
+    child_names = set()   
+    
+    if not hasattr(self, 'name') or not self.name:            
+        errors.append(f"The block with {[str(type(gui)).split('.')[-1] for gui in flatten(self.value)]} does not contain name!")
+        self.name = 'Unknown'          
+    if not isinstance(self.name, str):
+        errors.append(f"The block with name {self.name} is not a string!")
+    for child in flatten(self.value):           
+        if not isinstance(child, Gui) or not child:
+            errors.append(f'The block {self.name} contains invalid element {child} instead of Gui+ object!') 
+        elif isinstance(child, Block):
+            errors.append(f'The block {self.name} contains block {child.name}. Blocks cannot contain blocks!')                                                                                                       
+        elif child.name in child_names and child.type != 'line':                        
+            errors.append(f'The block {self.name} contains a duplicated element name "{child.name}"!')
+        elif child.type == 'chart' and not hasattr(child, 'view'):
+            errors.append(f'The block {self.name} contains a chart type "{child.name}", but not "view" option!')
+        else:
+            child_names.add(child.name)                
+    return errors
+
+def check_screen(module):
+    self = module.screen
+    errors =  []        
+    block_names = set()        
+    if not hasattr(self, 'name') or not self.name:            
+        errors.append(f"Screen file {module.__file__} does not contain name!")
+        self.name = 'Unknown'
+    elif not isinstance(self.name, str):
+        errors.append(f"The name in screen file {module.__file__} {self.name} is not a string!")
+    if not isinstance(self.blocks, list):
+        errors.append(f"Screen file {module.__file__} does not contain 'blocks' list!")
+    else:
+        for bl in flatten(self.blocks):            
+            if not isinstance(bl, Block):
+                errors.append(f'The screen contains invalid element {bl} instead of Block object!')                                                    
+            elif bl.name in block_names:
+                errors.append(f'The screen contains a duplicated block name {bl.name}!')    
+            else:            
+                block_names.add(bl.name)
+            errors += check_block(bl)
+    if errors:
+        errors.insert(0, f"\nErrors in screen {self.name}, file name {module.__file__}:")
+    return errors
+    
+def run_tests():
+    if not os.path.exists(testdir):
+        os.makedirs(testdir)
+    user = User.UserType()
+    user.load()
+    user.session = 'autotest'
+    errors = []
+    for module in user.screens:
+        errors += check_screen(module)
+    if errors:
+        errors.insert(0, f'\n!!----Unisi detected errors in screens:')
+        print('\n'.join(errors), '\n')
+    elif user.screens:
+        print(f'\n----The screen definitions are correct.-----\n')
+        
+    files = config.autotest
+    ok = True
+    process = False
+    if os.path.exists(testdir):
+        for file in os.listdir(testdir):
+            if not os.path.isdir(file) and (files == '*' or file in files):
+                process = True
+                if not test(file,user):
+                    ok = False
+    if process and ok:
+        print('\n-----Autotests successfully passed.-----\n')
+    User.last_user = None
+    User.toolbar.append(button)
+    
+        
+
+            

unisi/common.py

@@ -0,0 +1,28 @@
+import json, jsonpickle
+
+def flatten(*arr):
+    for a in arr:
+        if isinstance(a, list):
+            yield from flatten(*a)
+        else:
+            yield a
+            
+class ArgObject:
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value) 
+
+class ReceivedMessage:
+    def __init__(self, data):
+        self.screen = data.get('screen')
+        self.block = data.get('block')
+        self.element = data.get('element')
+        self.event = data.get('event')
+        self.value = data.get('value')  
+
+def toJson(obj, indent = 0, pretty = False):
+    js = jsonpickle.encode(obj,unpicklable=False)
+    return json.dumps(json.loads(js), indent=indent, sort_keys=pretty) if pretty else js
+
+
+

unisi/containers.py

@@ -0,0 +1,97 @@
+from .guielements import Gui, Range, Edit, Switch, Select
+
+class ContentScaler(Range):
+    def __init__(self, *args, **kwargs):
+        name = args[0] if args else 'Scale content'        
+        super().__init__(name, *args, **kwargs)                
+        if 'options' not in kwargs:
+            self.options = [0.25, 3.0, 0.25]
+        self.changed = self.scaler
+        
+    def scaler(self, _, val):
+        prev = self.value
+        elements = self.elements() 
+        self.value = val
+        if elements:
+            prev /= val
+            for element in elements:
+                element.width /= prev
+                element.height /= prev            
+            return elements
+        
+class Block(Gui):
+    def __init__(self, name, *elems, **options):        
+        self.name = name        
+        self.type = 'block'
+        self.value = list(elems)        
+        self.add(options)  
+        if hasattr(self,'scaler'):
+            scaler = ContentScaler(elements = lambda: self.scroll_list)
+            self.scaler = scaler
+            if not self.value:
+                self.value = [[scaler]]
+            elif isinstance(self.value[0], list):
+                self.value[0].append(scaler)
+            else:
+                self.value[0] = [self.value, scaler]
+    @property
+    def scroll_list(self):            
+        return self.value[1] if len(self.value) > 1 and isinstance(self.value[1], (list, tuple)) else []
+    
+    @scroll_list.setter
+    def scroll_list(self, lst):
+        self.value = [self.value[0] if self.value else [], lst]
+        if hasattr(self,'scaler'):
+            sval = self.scaler.value
+            if sval != 1:
+                self.scaler.value = 1
+                self.scaler.changed(self.scaler, sval)
+
+class ParamBlock(Block):
+    def __init__(self, name, *args, row = 3, **params):
+        if not args:
+            args = [[]]
+        super().__init__(name, *args)
+        self.name2elem = {}
+        cnt = 0        
+
+        for param, val in params.items():                    
+            pretty_name = param.replace('_',' ')
+            pretty_name = pretty_name[0].upper() + pretty_name[1:]
+            t = type(val)
+            if t == str:
+                el = Edit(pretty_name, val)
+            elif t == bool:
+                el = Switch(pretty_name, val)
+            elif t == list or t == tuple:
+                el = Select(pretty_name, val[0], options = val, type = 'select')
+            else:
+                el = Edit(pretty_name, val, type = 'number')
+            self.name2elem[param] = el
+            
+            if cnt % row == 0:
+                block = []
+                self.value.append(block)
+            cnt += 1
+            block.append(el)
+    @property
+    def params(self):
+        return {name: el.value for name, el in self.name2elem.items()}
+
+class Dialog:  
+    def __init__(self, question, callback, *content, commands = ['Ok','Cancel'],
+            icon = 'not_listed_location'):        
+        self.type = 'dialog'         
+        self.name = question
+        self.changed = callback          
+        self.commands = commands
+        self.icon = icon
+        self.value = [[], *content] if content else []        
+
+class Screen:
+    def __init__(self, name, **kwargs):
+        self.name = name
+        self.type = 'screen'
+        for key, value in kwargs.items():
+            setattr(self, key, value) 
+

unisi/guielements.py

@@ -0,0 +1,160 @@
+class Gui:
+    def __init__(self, name, *args, **kwargs):
+        self.name = name
+        la = len(args)
+        if la:
+            self.value = args[0]
+        if la > 1:
+            self.changed = args[1]                    
+        self.add(kwargs) 
+        
+    def add(self, kwargs):              
+        for key, value in kwargs.items():
+            setattr(self, key, value) 
+
+    def mutate(self, obj):
+        self.__dict__ = obj.__dict__ 
+    
+    def accept(self, value):
+        if hasattr(self, 'changed'):
+            self.changed(self, value)
+        else:
+            self.value = value
+
+Line = Gui("Line", type = 'line')
+
+def smart_complete(lst, min_input_length = 0, max_output_length = 20):
+    di = {it: it.lower() for it in lst}
+    def complete(gui, ustr):
+        if len(ustr) < min_input_length:
+            return []
+        ustr = ustr.lower()
+        arr = [(itlow.find(ustr), it, itlow) for it, itlow in di.items() if itlow.find(ustr) != -1]
+        arr.sort(key=lambda e: (e[0], e[2]))
+        if len(arr) > max_output_length:
+            arr = arr[: max_output_length]
+        return [e[1] for e in arr]
+    return complete
+
+class Edit(Gui):
+    def __init__(self, name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)        
+        has_value = hasattr(self,'value')
+        if 'type' not in kwargs:            
+            if has_value:
+                type_value = type(self.value)
+                if type_value == int or type_value == float:
+                    self.type = 'number'
+                    return
+            self.type =  'autoedit' if 'complete' in kwargs else 'edit'
+        if not has_value:
+            self.value = '' if self.type != 'number' else 0
+
+class Text(Gui):
+    def __init__(self, name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)
+        self.value = self.name
+        self.type = 'text'        
+
+class Range(Gui):
+    def __init__(self, name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)    
+        if not hasattr(self, 'value'):
+            self.value = 1.0    
+        self.type = 'range'                
+        if 'options' not in kwargs:
+            self.options = [self.value - 10, self.value + 10, 1]
+
+class Button(Gui):
+    def __init__(self, name, handler = None, **kwargs):
+        self.name = name
+        self.add(kwargs)
+        if not hasattr(self, 'type'):
+            self.type = 'command'
+        if handler:
+            self.changed = handler
+            
+def CameraButton(name, handler = None, **kwargs):    
+    kwargs['type'] = 'camera'
+    return Button(name, handler, **kwargs)
+        
+def UploadButton(name, handler = None,**kwargs):    
+    kwargs['type'] = 'image_uploader'
+    if 'width' not in kwargs:
+        kwargs['width'] = 250.0                  
+    return Button(name, handler, **kwargs)
+
+class Image(Gui):
+    '''has to contain file parameter as name'''
+    def __init__(self,name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)
+        self.type='image'
+        if not hasattr(self,'width'):
+            self.width = 500.0              
+        if not hasattr(self,'url'):
+            self.url = self.name
+        #mask full win path from Chrome detector
+        if self.url[1] == ':': 
+            self.url = f'/{self.url}'
+
+class Video(Gui):
+    '''has to contain src parameter'''
+    def __init__(self,name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)
+        self.type = 'video'
+        if not hasattr(self,'width'):
+            self.width = 300.0              
+        if not hasattr(self,'url'):
+            self.url = self.name
+        if not hasattr(self,'ratio'):
+            self.ratio = None
+
+graph_default_value = {'nodes' : [], 'edges' : []}
+
+class Graph(Gui):
+    '''has to contain nodes, edges, see Readme'''
+    def __init__(self, name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)
+        self.type='graph'
+        if not hasattr(self,'value'):
+            self.value = graph_default_value
+        if not hasattr(self,'minwidth'):
+            self.minwidth = 600.0                      
+        if not hasattr(self, 'nodes'):
+            self.nodes = []
+        if not hasattr(self, 'edges'):
+            self.edges = []
+
+class Switch(Gui):
+    def __init__(self,name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)        
+        if not hasattr(self,'value'):
+            self.value = False
+        if not hasattr(self,'type'):
+            self.type = 'switch'
+
+class Select(Gui):
+    def __init__(self,name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)
+        if not hasattr(self,'options'):             
+            self.options = []
+        if not hasattr(self,'value'):
+            self.value = None
+        if not hasattr(self, 'type'):
+            self.type = 'select' if len(self.options) > 3 else 'radio'        
+
+class Tree(Gui):
+    def __init__(self,name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)         
+        self.type = 'tree' 
+        if not hasattr(self,'options'):
+            self.options = {}        
+        if not hasattr(self,'value'):
+            self.value = None        
+        
+class TextArea(Gui):
+    def __init__(self,name, *args, **kwargs):
+        super().__init__(name, *args, **kwargs)
+        self.type = 'textarea' 
+                     
+        

unisi/proxy.py

@@ -0,0 +1,159 @@
+from websocket import create_connection
+from enum import Enum
+
+from .common import *
+
+class Event(Enum):
+    none = 0
+    update = 1
+    invalid = 2
+    message = 4
+    update_message = 6
+    progress = 12
+    update_progress = 13
+    unknown = 16
+    unknown_update = 17
+    dialog = 32
+    screen = 65
+    complete = 128
+    append = 256    
+
+ws_header = 'ws://'
+wss_header = 'wss://'
+ws_path = 'ws'
+
+message_types = ['error','warning','info']
+
+class Proxy:
+    """UNISI proxy"""
+    def __init__(self, addr_port, timeout = 3, ssl = False):
+       if not addr_port.startswith(ws_header) and not addr_port.startswith(wss_header):
+           addr_port = f'{wss_header if ssl else ws_header}{addr_port}'
+           addr_port = f'{addr_port}{"" if addr_port.endswith("/") else "/"}{ws_path}'
+                      
+       self.conn = create_connection(addr_port, timeout = timeout)
+       self.screen = None       
+       self.screens = {}
+       self.dialog = None
+       self.event = None
+       self.request(None)
+
+    def close(self):
+        self.conn.close()
+
+    @property
+    def screen_menu(self):
+        return [name_icon[0] for name_icon in self.screen['menu']] if self.screen else []
+    
+    @property
+    def commands(self, names = False):
+        """return command objects or its names"""
+        celems = self.elements(types=['command'])        
+        return [el['name'] for el in celems] if names else celems        
+    
+    def elements(self, block = None, types = None):
+        """get elements with filtering types and blocks"""
+        if block:
+            return [el for el in flatten(block['value']) if not types or el['type'] in types]
+        answer = []
+        for block in self.screen['name2block'].values(): 
+            answer.extend([el for el in flatten(block['value']) if not types or el['type'] in types])
+        return answer
+    
+    def block_of(self, element):
+        for block in self.screen['name2block'].values():
+            for el in flatten(block['value']):
+                if el == element:
+                    return block
+    
+    def message(self, element, value, event = 'changed'):
+        if event != 'changed' and event not in element:
+            return None
+        return ArgObject(block = self.block_of(element), element = element['name'], 
+            event = event, value = value)
+    
+    def interact(self, message, progress_callback = None):
+        """progress_callback is def (proxy:Proxy)"""        
+        while self.request(message) & Event.progress:
+            if progress_callback:
+                progress_callback(self)
+            message = None
+        return self.event
+    
+    def request(self, message):
+        """send message or message list, get responce, return the responce type"""
+        if message:
+            self.conn.send(toJson(message))
+        responce = self.conn.recv()
+        message = json.loads(responce) 
+        return self.process(message) 
+    
+    def set_screen(self, name):
+        screen = self.screens.get(name)
+        if not screen:
+            if name in self.screen_menu:
+                mtype = self.request(ArgObject(block = 'root', element = None, value = name))
+                return mtype == Event.screen 
+            else:
+                return False
+        return True 
+    
+    @property
+    def dialog_commands(self):
+        return self.dialog['commands'] if self.dialog else []
+    
+    def dialog_responce(self, command: str | None):
+        if not self.dialog:
+            self.event = Event.invalid
+            return  self.event
+        return self.interact(ArgObject(block = self.dialog['name'], value = command))
+       
+    def process(self, message):        
+        self.message = message   
+        if not message:
+            self.event = Event.none 
+            self.mtype = None
+        else:    
+            mtype = message.get('type')        
+            self.mtype = mtype
+            if mtype == 'screen':
+                self.screen = message
+                self.screens[self.screen['name']] = message
+                name2block = {block['name']: block for block in flatten(message['blocks'])}            
+                name2block['toolbar'] = {'name': 'toolbar', 'value': message['toolbar']}
+                message['name2block'] = name2block
+                self.event = Event.screen
+            elif mtype == 'dialog':
+                self.dialog = message
+                self.event = Event.dialog
+            elif mtype == 'complete':
+                return Event.complete
+            elif mtype == 'append':
+                self.event = Event.append
+            elif mtype == 'update':
+                self.update(message)
+                self.event = Event.update
+            else:
+                updates = message.get('updates')
+                if updates:
+                    self.update(message)                                        
+                if type in message_types:
+                    self.event = Event.update_message if updates else Event.message 
+                if type == 'progress':
+                    self.event = Event.update_progress if updates else Event.progress
+                else:
+                    self.event = Event.unknown_update if updates else Event.unknown
+        return self.event
+        
+    def update(self, message):
+        """update screen from the message"""
+        updates = message.updates
+        for update in updates:
+            path = update['path']
+            name2block = self.screen['name2block']
+            if len(path) == 1: #block
+                name2block[block] = update['data']
+            else:
+                block, element = path
+                name2block[block][element] = update['data']
+