unisi 0.1.0__py3-none-any.whl

unisi/reloader.py

@@ -0,0 +1,150 @@
+from .autotest import config
+
+empty_app = {
+    "blocks": [],
+    "header": "No screens",
+    "icon": None,
+    "menu": [["You need to put at least 1 file in the 'screens' folder.",'exclamation']],
+    "name": "",
+    "order": 0,
+    "toolbar": [],
+    "type": "screen"
+}
+
+if config.hot_reload:
+    import os, sys, traceback
+    from watchdog.observers import Observer
+    from watchdog.events import PatternMatchingEventHandler
+    from .users import User
+    from .utils import divpath, Redesign, app_dir
+    from .autotest import check_screen
+    import re, collections
+
+    #for removing message duplicates        
+    file_content = collections.defaultdict(str)
+    
+    busy = False      
+    cwd = os.getcwd()  
+
+    def free():
+        global busy
+        if request_file:
+            reload(request_file)
+        else:
+            busy = False
+
+    def reload(sname):
+        user = User.last_user
+        if user:
+            file = open(f'screens{divpath}{sname}', "r") 
+            content = file.read()
+            if file_content[sname] == content:
+                return
+            file_content[sname] = content
+            
+            global busy, request_file
+            busy = True
+            request_file = None            
+
+            try:
+                module = user.load_screen(sname)
+                errors = check_screen(module)                                
+                if errors:
+                    print('\n'.join(errors))
+                    busy = False
+                    return 
+                print('Reloaded.') 
+            except:
+                traceback.print_exc()        
+                busy = False                
+                return
+
+            for i, s in enumerate(user.screens):
+                if s.__file__ == module.__file__:
+                    same = user.screen_module.__file__ == module.__file__
+                    user.screens[i] = module
+                    if same:
+                        user.set_screen(module.screen.name)            
+                    break
+            else:
+                user.screens.append(module)
+                if len(user.screens) == 1:
+                    user.set_screen(module.name)                    
+
+            user.update_menu()
+            user.set_clean() 
+            user.sync_send(Redesign)
+
+            free()  
+            return module  
+
+    class ScreenEventHandler(PatternMatchingEventHandler):    
+        def on_modified(self, event):
+            if not event.is_directory and User.last_user:                            
+                short_path = event.src_path[len(cwd) + 1:]
+                arr = short_path.split(divpath) 
+                name = arr[-1]
+                dir = arr[0] if len(arr) > 1 else '' 
+                                
+                if name.endswith('.py'):
+                    user = User.last_user
+                    
+                    if user.screen_module and dir not in ['screens','blocks']: 
+                        #analyze if dependency exist
+                        file = open(user.screen_module.__file__, "r") 
+                        arr[-1] = arr[-1][:-3]
+                        module_name = '.'.join(arr) 
+                        module_pattern = '\.'.join(arr)                        
+                        
+                        if re.search(f"((import|from)[ \t]*{module_pattern}[ \t\n]*)",file.read()):
+                            if module_name in sys.modules:
+                                del sys.modules[module_name]                            
+                            short_path = user.screen_module.__file__
+                            if short_path.startswith(app_dir):
+                                short_path = short_path[len(app_dir) + 1:]
+                            dir, name = short_path.split(divpath)                            
+
+                    if dir in ['screens','blocks']:                             
+                        if busy:
+                            global request_file            
+                            request_file = short_path 
+                        else:                    
+                            fresh_module = reload(name) if dir == 'screens' else None                                            
+                            module = user.screen_module
+                            if module:
+                                current = module.__file__
+                                if not fresh_module or current != fresh_module.__file__:
+                                    reload(current.split(divpath)[-1]) 
+                                                    
+        def on_deleted(self, event):            
+            if not event.is_directory and User.last_user:
+                user = User.last_user            
+                arr = event.src_path.split(divpath) 
+                name = arr[-1]
+                dir = arr[-2]  
+                if name.endswith('.py') and dir == 'screens':
+                    delfile = f'{dir}{divpath}{name}'
+                    for i, s in enumerate(user.screens):
+                        if s.__file__ == event.src_path:
+                            user.screens.remove(s)
+                            if user.screen_module is s:
+                                if user.screens:                                                                        
+                                    fname = user.screens[0].__file__.split(divpath)[-1]
+                                    module = reload(fname)
+                                    user.set_screen(module.name)
+                                    user.update_menu()                                
+                                    user.sync_send(Redesign)      
+                                else:                                                      
+                                    user.sync_send(empty_app)                                                        
+                            else:
+                                reload(user.screen_module.__file__.split(divpath)[-1])
+                                user.update_menu()
+                                user.sync_send(Redesign)                                                        
+                            break
+    
+    event_handler = ScreenEventHandler()
+    observer = Observer()
+    path = os.getcwd()
+    observer.schedule(event_handler, path, recursive = True)
+    observer.start()
+    

unisi/server.py

@@ -0,0 +1,118 @@
+from aiohttp import web, WSMsgType
+from .users import *
+from pathlib import Path
+from .reloader import empty_app 
+from .autotest import recorder, jsonString, run_tests
+from .common import  *
+from config import port, upload_dir
+import traceback
+
+async def post_handler(request):
+    reader = await request.multipart()
+    field = await reader.next()   
+    filename = upload_path(field.filename)      
+    size = 0
+    with open(filename, 'wb') as f:
+        while True:
+            chunk = await field.read_chunk()  
+            if not chunk:
+                break
+            size += len(chunk)
+            f.write(chunk)
+
+    return web.Response(text=filename)
+
+async def static_serve(request):    
+    rpath = request.path    
+    file_path  = Path(f"{webpath}{rpath}" )
+    if request.path == '/':
+        file_path /= 'index.html'
+
+    if not file_path.exists():
+        file_path = None
+        #unmask win path
+        if rpath.startswith('/') and rpath[2] == ':':
+            rpath = rpath[1:]
+        dirs = getattr(config, public_dirs, []) 
+        for dir in dirs:              
+            if rpath.startswith(dir):                
+                if os.path.exists(rpath):
+                    file_path  = Path(rpath)
+                break
+            
+    return web.FileResponse(file_path) if file_path else web.HTTPNotFound()
+     
+def broadcast(message, message_user):
+    screen = message_user.screen_module
+    for user in User.reflections:
+        if user is not message_user and screen is user.screen_module:
+            user.sync_send(message)
+
+async def websocket_handler(request):
+    ws = web.WebSocketResponse()
+    await ws.prepare(request)
+    user, ok = make_user()
+    user.transport = ws._writer.transport  if divpath != '/' else None          
+
+    async def send(res):
+        if type(res) != str:
+            res = jsonString(user.prepare_result(res))        
+        await ws.send_str(res)        
+
+    user.send = send     
+    user.session = request.remote    
+    await send(user.screen if ok else empty_app) 
+    try:
+        async for msg in ws:
+            if msg.type == WSMsgType.TEXT:
+                if msg.data == 'close':
+                    await ws.close()
+                else:
+                    raw_message = json.loads(msg.data)
+                    if isinstance(raw_message, list):
+                        for raw_submessage in raw_message:
+                            message = ReceivedMessage(raw_submessage)                    
+                            result = user.result4message(message)
+                        else:                        
+                            message = None
+                            result = Error('Empty command batch!')
+                    else:                    
+                        message = ReceivedMessage(raw_message)            
+                        result = user.result4message(message)                    
+                    await send(result)
+                    if message:
+                        if recorder.record_file:
+                            recorder.accept(message, result)
+                        if config.mirror and not is_screen_switch(message):                        
+                            if result:
+                                broadcast(result, user)                            
+                            msg_object = user.find_element(message)                         
+                            if not isinstance(result, Message) or not result.contains(msg_object):                                                        
+                                broadcast(jsonString(user.prepare_result(msg_object)), user)
+            elif msg.type == WSMsgType.ERROR:
+                user.log('ws connection closed with exception %s' % ws.exception())
+    except:        
+        user.log(traceback.format_exc())
+
+    if User.reflections:
+        User.reflections.remove(user)
+    return ws       
+
+def start(appname = None, user_type = User, http_handlers = []):    
+    if appname is not None:
+        config.appname = appname
+
+    User.UserType = user_type    
+
+    if config.autotest:
+        run_tests()
+
+    http_handlers.insert(0, web.get('/ws', websocket_handler))        
+    http_handlers += [web.static(f'/{config.upload_dir}', upload_dir), 
+        web.get('/{tail:.*}', static_serve), web.post('/', post_handler)]
+
+    print(f'Start {appname} web server..')    
+    app = web.Application()
+    app.add_routes(http_handlers)    
+    web.run_app(app,  port=port)
+    

unisi/tables.py

@@ -0,0 +1,116 @@
+from .guielements import Gui
+
+def accept_cell_value(table, val):    
+    value, position = val
+    if not isinstance(value, bool):
+        try:
+            value = float(value)        
+        except ValueError:
+            pass
+        table.rows[position[0]][position[1]] = value    
+
+def delete_table_row(table, value):
+    if table.rows:        
+        keyed = len(table.headers) < len(table.rows[0])
+        table.value = value   
+        if isinstance(value, list):        
+            if keyed:
+                table.rows = [row for row in table.rows if row[-1] not in value]
+            else:
+                value.sort(reverse=True)
+                for v in value:            
+                    del table.rows[v]
+            table.value = []
+        else:
+            if keyed:            
+                table.rows = [row for row in table.rows if row[-1] != value]
+            else:
+                del table.rows[value]  
+            table.value = None    
+
+def append_table_row(table, value):
+    ''' append has to return new row or error string, val is search string in the table'''
+    new_id_row, search = value #new_id_row == rows count
+    new_row = [''] * len(table.headers)
+    if search:
+        new_row[0] = search
+    table.rows.append(new_row)
+    return new_row
+
+class Table(Gui):
+    def __init__(self, *args, panda = None, **kwargs):
+        if panda is not None:
+            self.mutate(PandaTable(*args, panda=panda, **kwargs))
+        else:
+            super().__init__(*args, **kwargs)           
+            if not hasattr(self,'headers'):
+                self.headers = []
+            if not hasattr(self,'type'):
+                self.type = 'table'
+            if not hasattr(self,'value'):
+                self.value = None
+            if not hasattr(self,'rows'):
+                self.rows = []        
+            if not hasattr(self,'dense'):
+                self.dense = True
+
+        if getattr(self,'edit', True): 
+            if not hasattr(self,'delete'):
+                self.delete = delete_table_row             
+            if not hasattr(self,'append'):
+                self.append = append_table_row             
+            if not hasattr(self,'modify'):
+                self.modify = accept_cell_value             
+        
+    def selected_list(self):                            
+        return [self.value] if self.value != None else [] if type(self.value) == int else self.value   
+
+    def clean(self):
+        self.rows = []
+        self.value = [] if isinstance(self.value,(tuple, list)) else None
+        return self
+
+def delete_panda_row(table, row_num):    
+    df = table.__panda__
+    if row_num < 0 or row_num >= len(df):
+        raise ValueError("Row number is out of range")
+    pt = table.__panda__
+    pt.drop(index = row_num,  inplace=True)
+    pt.reset_index(inplace=True) 
+    delete_table_row(table, row_num)    
+
+def accept_panda_cell(table, value_pos):
+    value, position = value_pos
+    row_num, col_num = position
+    table.__panda__.iloc[row_num,col_num] = value
+    accept_cell_value(table, value_pos)
+
+def append_panda_row(table, row_num):    
+    df = table.__panda__
+    new_row = append_table_row(table, row_num)
+    df.loc[len(df), df.columns] = new_row
+    return new_row    
+
+class PandaTable(Table):
+    """ panda = opened panda table"""
+    def __init__(self, *args, panda = None, fix_headers = True, **kwargs):
+        super().__init__(*args, **kwargs)                
+        if panda is None:
+            raise Exception('PandaTable has to get panda = pandaTable as an argument.')
+        self.headers = panda.columns.tolist()
+        if fix_headers:
+            self.headers = [header.replace('_',' ') for header in self.headers]        
+        self.rows = panda.values.tolist()
+        self.__panda__ = panda
+
+        if getattr(self,'edit', True): 
+            if not hasattr(self,'delete'):
+                self.delete = delete_panda_row             
+            if not hasattr(self,'append'):
+                self.append = append_panda_row             
+            if not hasattr(self,'modify'):
+                self.modify = accept_panda_cell            
+    @property
+    def panda(self):
+        return getattr(self,'__panda__',None) 
+    

unisi/users.py

@@ -0,0 +1,271 @@
+import importlib
+from .utils import *
+from .guielements import *
+from .common import *
+from .containers import Dialog, Screen
+import sys
+import asyncio
+from threading import Thread
+import logging  
+
+class User:      
+    def __init__(self):          
+        self.screens = []        
+        self.active_dialog = None
+        self.screen_module = None 
+        self.session = None   
+        self.__handlers__ = {}      
+        self.last_message = None              
+        User.last_user = self   
+
+    async def send_windows(self, obj):  
+        await self.send(obj)        
+        self.transport._write_fut = None
+        self.transport._loop._ready.pop()
+
+    def sync_send(self, obj):                    
+        asyncio.run_coroutine_threadsafe(self.send_windows(obj) 
+            if self.transport else self.send(obj), self.extra_loop)
+
+    def progress(self, str, *updates):
+        """open or update progress window if str != null else close it  """  
+        if not self.testing:           
+            self.sync_send(TypeMessage('progress', str, *updates, user = self))
+                   
+    def load_screen(self, file):
+        screen_vars = {
+            'icon' : None,
+            'prepare' : None,            
+            'blocks' : [],
+            'header' : config.appname,                        
+            'toolbar' : [], 
+            'order' : 0,
+            'reload': config.hot_reload 
+        }             
+        name = file[:-3]        
+        path = f'{screens_dir}{divpath}{file}'                
+        spec = importlib.util.spec_from_file_location(name,path)
+        module = importlib.util.module_from_spec(spec)        
+                
+        module.user = self                               
+        
+        spec.loader.exec_module(module)            
+        screen = Screen(getattr(module, 'name', ''))
+        #set system vars
+        for var in screen_vars:                                            
+            setattr(screen, var, getattr(module,var,screen_vars[var]))         
+        
+        if screen.toolbar:
+            screen.toolbar += User.toolbar
+        else: 
+            screen.toolbar = User.toolbar  
+                                
+        module.screen = screen        
+        return module
+
+    def set_clean(self):
+        #remove user modules from sys 
+        if os.path.exists(blocks_dir):
+            for file in os.listdir(blocks_dir):
+                if file.endswith(".py") and file != '__init__.py':
+                    name = f'{blocks_dir}.{file[0:-3]}'
+                    if name in sys.modules:
+                        sys.modules[name].user = self
+                        del sys.modules[name]                          
+    def load(self):              
+        if os.path.exists(screens_dir):
+            for file in os.listdir(screens_dir):
+                if file.endswith(".py") and file != '__init__.py':
+                    module = self.load_screen(file)                
+                    self.screens.append(module)                
+            
+        if self.screens:
+            self.screens.sort(key=lambda s: s.screen.order)            
+            main = self.screens[0]
+            if 'prepare' in dir(main):
+                main.prepare()
+            self.screen_module = main
+            self.update_menu()
+            self.set_clean()       
+            return True                 
+
+    def update_menu(self):
+        menu = [[getattr(s, 'name', ''),getattr(s,'icon', None)] for s in self.screens]        
+        for s in self.screens:
+            s.screen.menu = menu
+
+    @property
+    def testing(self):        
+        return  self.session == 'autotest'
+    
+    @property
+    def screen(self):        
+        return  self.screen_module.screen 
+
+    def set_screen(self,name):
+        return self.process(ArgObject(block = 'root', element = None, value = name))
+
+    def result4message(self, message):
+        result = None
+        dialog = self.active_dialog
+        if dialog:            
+            if message.element is None: #button pressed
+                self.active_dialog = None                
+                result = dialog.changed(dialog, message.value) 
+            else:
+                el = self.find_element(message)
+                if el:
+                    result = self.process_element(el, message)                        
+        else:
+            result = self.process(message)           
+        if result and isinstance(result, Dialog):
+            self.active_dialog = result
+        return result
+
+    @property
+    def blocks(self):
+        return [self.active_dialog] if self.active_dialog and \
+            self.active_dialog.value else self.screen.blocks
+
+    def find_element(self, message):               
+        blname = message.block
+        elname = message.element
+        if blname == 'toolbar':
+            for e in self.screen.toolbar:
+                if e.name == elname:                
+                    return e
+        else:
+            for bl in flatten(self.blocks):
+                if bl.name == blname:
+                    for c in bl.value:
+                        if isinstance(c, list):
+                            for sub in c:
+                                if sub.name == elname:
+                                    return sub
+                        elif c.name == elname:
+                            return c
+        
+    def find_path(self, elem):        
+        for bl in flatten(self.blocks):        
+            if bl == elem:
+                return [bl.name]
+            for c in bl.value:
+                if isinstance(c, list):
+                    for sub in c:
+                        if sub == elem:
+                            return [bl.name, sub.name]
+                elif c == elem:
+                    return [bl.name, c.name]
+        for e in self.screen.toolbar:
+            if e == elem:                
+                return ['toolbar', e.name]
+
+    def prepare_result(self, raw):
+        if raw == UpdateScreen:
+            raw = self.screen      
+            raw.reload = False                  
+        elif raw == Redesign:
+            raw = self.screen      
+            raw.reload = True                  
+        else:
+            if isinstance(raw, Message):
+                raw.fill_paths4(self)                
+            elif isinstance(raw,Gui):
+                raw = Message(raw, user = self)                 
+            elif isinstance(raw, (list, tuple)):
+                raw = Message(*raw, user = self)
+        return raw
+
+    def process(self, message):
+        self.last_message = message     
+        screen_change_message = message.screen and self.screen.name != message.screen   
+        if is_screen_switch(message) or screen_change_message:
+            for s in self.screens:
+                if s.name == message.value:
+                    self.screen_module = s                    
+                    if screen_change_message:
+                        break
+                    if getattr(s.screen,'prepare', False):
+                        s.screen.prepare()
+                    return True 
+            else:        
+                error = f'Unknown screen name: {message.value}'   
+                self.log(error)
+                return Error(error)
+        
+        elem = self.find_element(message)          
+        if elem:                          
+            return self.process_element(elem, message)  
+        
+        error = f'Element {message.block}>>{message.element} does not exists!'
+        self.log(error)
+        return Error(error)
+        
+    def process_element(self, elem, message):                
+        event = message.event        
+        query = event in ['complete', 'append']
+        
+        handler = self.__handlers__.get((elem, event), None)
+        if handler:
+            result = handler(elem, message.value)                
+            return result
+        
+        handler = getattr(elem, event, False)                                
+        if handler:                
+            result = handler(elem, message.value)  
+            if query:                        
+                result = Answer(event, message, result)                
+            return result
+        elif event == 'changed':            
+            elem.value = message.value                                        
+        else:
+            self.log(f'{elem} does not contain method for {event} event type!')                     
+            return Error(f'Invalid {event} event type for {message.block}>>{message.element} is received!')
+
+    def reflect(self):        
+        user = User.UserType()
+        user.screens = self.screens
+        if self.screens:
+            user.screen_module = self.screens[0]     
+        user.__handlers__ =  self.__handlers__        
+        return user
+
+    def log(self, str, type = 'error'):        
+        scr = self.screen.name if self.screens else 'omitted'
+        str = f"session: {self.session}, screen: {scr}, message: {self.last_message} \n  {str}"
+        if type == 'error':
+            logging.error(str)
+        else:
+            logging.warning(str)    
+
+def make_user():
+    if config.mirror and User.last_user:
+        user = User.last_user.reflect()
+        ok = user.screens
+    else:
+        user = User.UserType()
+        ok = user.load()
+    if config.mirror:
+        User.reflections.append(user)         
+    return user, ok
+
+#loop and thread is for progress window and sync interactions
+loop = asyncio.new_event_loop()
+
+def f(loop):
+    asyncio.set_event_loop(loop)
+    loop.run_forever() 
+
+async_thread = Thread(target=f, args=(loop,))
+async_thread.start()
+
+def handle(elem, event):
+    def h(fn):
+        User.last_user.__handlers__[elem, event] = fn
+    return h
+
+User.extra_loop = loop
+User.UserType = User
+User.last_user = None
+User.toolbar = []
+User.reflections = []