unisi 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

unisi/__init__.py

@@ -1,6 +1,6 @@
 from .utils import *
 from .guielements import *
-from .users import User, handle
+from .users import User, handle, context_user, context_screen
 from .server import start
 from .tables import *
 from .containers import *

unisi/autotest.py

@@ -9,32 +9,9 @@ from .jsoncomparison import Compare, NO_DIFF
 def obj2json(obj):
     return json.loads(toJson(obj))
 
-#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, '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(rules = {'toolbar': '*'}).check
 
 class Recorder:
@@ -202,7 +179,7 @@ def check_module(module):
 def run_tests():
     if not os.path.exists(testdir):
         os.makedirs(testdir)
-    user = User.type('autotest')
+    user = User.type(testdir)
     user.load()    
     errors = []
     for module in user.screens:

unisi/common.py

@@ -9,16 +9,15 @@ def flatten(*arr):
             
 class ArgObject:
     def __init__(self, **kwargs):
-        for key, value in kwargs.items():
-            setattr(self, key, value) 
+        self.__dict__.update(kwargs)
 
 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')  
+        self.__dict__.update(data)
+        self.screen = data.get('screen')        
+        self.value = data.get('value')        
+    def __str__(self):
+        return f'{self.block}/{self.element}->{self.event}({self.value})'
 
 def toJson(obj):
     return jsonpickle.encode(obj,unpicklable = False)

unisi/containers.py

@@ -103,8 +103,7 @@ class Dialog:
 
 class Screen:
     def __init__(self, name, **kwargs):
-        self.name = name
+        self.name = name        
+        self.__dict__.update(kwargs) 
         self.type = 'screen'
-        for key, value in kwargs.items():
-            setattr(self, key, value) 
 

unisi/guielements.py

@@ -9,8 +9,7 @@ class Gui:
         self.add(kwargs) 
         
     def add(self, kwargs):              
-        for key, value in kwargs.items():
-            setattr(self, key, value) 
+        self.__dict__.update(kwargs) 
 
     def mutate(self, obj):
         self.__dict__ = obj.__dict__ 
@@ -25,12 +24,12 @@ 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):
+    def complete(_, 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]))
+        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]

unisi/multimon.py

@@ -0,0 +1,101 @@
+import multiprocessing, time, asyncio, logging, inspect
+from .utils import start_logging
+from config import froze_time, monitor_tick, profile, pool
+
+def write_string_to(shared_array, input_string):    
+    input_bytes = input_string.encode()    
+    shared_array[:len(input_bytes)] = input_bytes
+
+def read_string_from(shared_array):
+    return shared_array[:].decode().rstrip('\x00')
+
+_multiprocessing_pool = None
+
+def multiprocessing_pool():
+    global _multiprocessing_pool
+    if not _multiprocessing_pool:
+        _multiprocessing_pool = multiprocessing.Pool(pool)
+    return _multiprocessing_pool
+
+async def run_external_process(long_running_task, *args, queue = None, progress_callback = None, **kwargs):
+    if progress_callback:
+        if queue is None:
+            queue = multiprocessing.Manager().Queue()
+        if args[-1] is None:                    
+            args = *args[:-1], queue            
+    result = multiprocessing_pool().apply_async(long_running_task, args, kwargs)
+    if progress_callback:
+        while not result.ready() or not queue.empty():            
+            message = queue.get()
+            if message is None:
+                break
+            await asyncio.gather(progress_callback(message), asyncio.sleep(monitor_tick))            
+    return result.get()
+
+logging_lock = multiprocessing.Lock()
+
+splitter = '~'
+
+def monitor_process(monitor_shared_arr):            
+    timer = None
+    session_status = {}    
+    sname = None    
+    start_logging()
+    while True:
+        #Wait for data in the shared array
+        while monitor_shared_arr[0] == b'\x00':
+            time.sleep(0.005)  
+            if timer is not None:
+                timer -= monitor_tick                
+                if timer < 0:
+                    timer = None                    
+                    arr = list(session_status.items())
+                    arr.sort(key = lambda s: s[1][1], reverse=True)
+                    ct = time.time()
+                    message = "Hangout is detected! Sessions in a queue and time waiting:" +\
+                        ''.join(f'\n  {s[0]}, {s[1][0]}, {ct - s[1][1]} s' for s in arr)    
+                    with logging_lock:
+                        logging.warning(message)                    
+                    timer = None
+        # Read and process the data
+        status = read_string_from(monitor_shared_arr).split(splitter)
+        #free
+        monitor_shared_arr[0] = b'\x00'
+        sname = status[1]  
+        match status[0]:
+            case '+' | 'e': #exit external process                             
+                session_status[sname] = [status[2], time.time()]
+                timer = froze_time
+            case '-':    
+                event, tstart = session_status.get(sname, (None, 0))
+                if event:                                        
+                    duration = time.time() - tstart
+                    if profile and duration > profile:
+                        with logging_lock:
+                            logging.warning(f'Event handler {event} was executed for {duration} seconds!')
+                    del session_status[sname] 
+                    timer = None
+            case 'p': #call external process
+                session_status[sname] = [status[2], time.time()]
+                timer = None
+                            
+if froze_time or profile: 
+    # Create a shared memory array
+    monitor_shared_arr = multiprocessing.Array('c', 200)  
+    monitor_shared_arr[0] != b'\x00'
+    
+    async def notify_monitor(status, session, event):
+        s = f'{status}{splitter}{session}{splitter}{event}'        
+        # Wait for the shared array to be empty
+        while monitor_shared_arr[0] != b'\x00':
+            await asyncio.sleep(monitor_tick)
+        write_string_to(monitor_shared_arr, s)
+
+    monitor_process = multiprocessing.Process(target=monitor_process, args=(monitor_shared_arr,))
+    monitor_process.start()
+else:
+    notify_monitor = None
+    
+
+
+        

unisi/proxy.py

@@ -30,7 +30,9 @@ class Proxy:
         addr_port = f'{wss_header if ssl else ws_header}{host_port}'
         addr_port = f'{addr_port}{"" if addr_port.endswith("/") else "/"}{ws_path}'
         self.host_port = f'{"https" if ssl else "http"}://{host_port}'
-        self.conn = create_connection(addr_port, timeout = timeout, header = {'session' : session})
+        if session:
+            addr_port = f'{addr_port}?{session}'
+        self.conn = create_connection(addr_port, timeout = timeout)
         self.screen = None       
         self.screens = {}
         self.dialog = None

unisi/server.py

@@ -49,8 +49,6 @@ async def websocket_handler(request):
     if not user:
         await ws.send_str(toJson(status))
     else:
-        user.transport = ws._writer.transport  if divpath != '/' else None          
-
         async def send(res):
             if type(res) != str:
                 res = toJson(user.prepare_result(res))        
@@ -80,31 +78,18 @@ async def websocket_handler(request):
                         if message:
                             if recorder.record_file:
                                 recorder.accept(message, user.prepare_result (result))
-                            await user.reflect(message, result)
-                            """ if user.reflections and not is_screen_switch(message):                        
-                                if result:
-                                    await broadcast(result, user)                            
-                                msg_object = user.find_element(message)                         
-                                if not isinstance(result, Message) or not result.contains(msg_object):                                                        
-                                    await broadcast(toJson(user.prepare_result(msg_object)), user) """
+                            await user.reflect(message, result)                            
                 elif msg.type == WSMsgType.ERROR:
                     user.log('ws connection closed with exception %s' % ws.exception())
-        except:        
-            user.log(traceback.format_exc())
+        except BaseException as e:
+            if not isinstance(e, ConnectionResetError):
+                user.log(traceback.format_exc())
 
-        uss = User.sessions
-        if uss and uss.get(user.session):
-            del uss[user.session]
-        
-        if user.reflections: #reflections is common array
-            if len(user.reflections) == 2: 
-                user.reflections.clear() #1 element in user.reflections has no sense
-            else:
-                user.reflections.remove(user)        
-    return ws  #?<->     
+        await user.delete()   
+    return ws     
 
 def start(appname = None, user_type = User, http_handlers = []):    
-    if appname is not None:
+    if appname:
         config.appname = appname
 
     User.type = user_type    

unisi/users.py

@@ -2,6 +2,7 @@ from .utils import *
 from .guielements import *
 from .common import *
 from .containers import Dialog, Screen
+from .multimon import notify_monitor, logging_lock, run_external_process
 import sys, asyncio, logging, importlib
 
 class User:      
@@ -25,13 +26,22 @@ class User:
             self.screens = []        
             self.reflections = []
             self.screen_module = None         
-            self.__handlers__ = {}              
+            self.__handlers__ = {} 
 
-    def sync_send(self, obj):                    
-        asyncio.run(self.send(obj))
+        self.monitor(session, share)     
+
+    async def run_process(self, long_running_task, *args, progress_callback = None, queue = None, **kwargs):
+        if progress_callback and notify_monitor and progress_callback != self.progress: #progress notifies the monitor
+            async def new_callback(value):
+                asyncio.gather(notify_monitor('e', self.session, self.last_message), progress_callback(value))                
+            progress_callback = new_callback
+        return await run_external_process(long_running_task, *args, progress_callback = progress_callback, 
+                queue = queue, **kwargs)
 
     async def broadcast(self, message):
         screen = self.screen_module
+        if type(message) != str:
+            message = toJson(self.prepare_result(message))  
         await asyncio.gather(*[user.send(message)
             for user in self.reflections
                 if user is not self and screen is user.screen_module])        
@@ -43,13 +53,15 @@ class User:
             if message:                    
                 msg_object = self.find_element(message)                                     
                 if not isinstance(result, Message) or not result.contains(msg_object):                                                        
-                    await self.broadcast(toJson(self.prepare_result(msg_object)))    
+                    await self.broadcast(msg_object)    
 
     async def progress(self, str, *updates):
         """open or update progress window if str != null else close it """  
         if not self.testing:           
             msg = TypeMessage('progress', str, *updates, user = self)            
             await asyncio.gather(self.send(msg), self.reflect(None, msg))
+            if notify_monitor:
+                await notify_monitor('e', self.session, self.last_message) 
                                            
     def load_screen(self, file):
         screen_vars = {
@@ -65,9 +77,8 @@ class User:
         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  
                 
-        module.user = self                               
-        
         spec.loader.exec_module(module)            
         screen = Screen(getattr(module, 'name', ''))
         #set system vars
@@ -78,9 +89,22 @@ class User:
             screen.toolbar += User.toolbar
         else: 
             screen.toolbar = User.toolbar  
-                                
-        module.screen = screen        
+        module.screen = screen                                 
         return module
+    
+    async def delete(self):
+        uss = User.sessions
+        if uss and uss.get(self.session):
+            del uss[self.session]
+        
+        if self.reflections: #reflections is common array
+            if len(self.reflections) == 2: 
+                self.reflections.clear() #1 element in user.reflections has no sense
+            else:
+                self.reflections.remove(self)  
+
+        if notify_monitor:
+            await notify_monitor('-', self.session, self.last_message)   
 
     def set_clean(self):
         #remove user modules from sys 
@@ -99,7 +123,7 @@ class User:
                     self.screens.append(module)                
             
         if self.screens:
-            self.screens.sort(key=lambda s: s.screen.order)            
+            self.screens.sort(key=lambda s: s.order)            
             main = self.screens[0]
             if 'prepare' in dir(main):
                 main.prepare()
@@ -115,7 +139,7 @@ class User:
 
     @property
     def testing(self):        
-        return  self.session == 'autotest'
+        return  self.session == testdir
     
     @property
     def screen(self):        
@@ -125,16 +149,14 @@ class User:
         return asyncio.run(self.process(ArgObject(block = 'root', element = None, value = name)))
 
     async def result4message(self, message):
-        result = None
-        dialog = self.active_dialog
-        if dialog:            
-            if message.element is None: #button pressed
+        result = None        
+        self.last_message = message     
+        if dialog := self.active_dialog:            
+            if message.element is None: #dialog command button is pressed
                 self.active_dialog = None    
                 if self.reflections:            
-                    await self.broadcast(TypeMessage('action', 'close'))
-                handler = dialog.changed
-                result = (await handler(dialog, message.value)) if asyncio.iscoroutinefunction(handler)\
-                      else handler(dialog, message.value)
+                    await self.broadcast(TypeMessage('action', 'close'))                                    
+                result = await self.eval_handler(dialog.changed, dialog, message.value)
             else:
                 el = self.find_element(message)
                 if el:
@@ -145,6 +167,15 @@ class User:
             self.active_dialog = result
         return result
 
+    async def eval_handler(self, handler, gui, value):
+        if notify_monitor:
+            await notify_monitor('+', self.session, self.last_message)        
+        result = (await handler(gui, value)) if asyncio.iscoroutinefunction(handler)\
+            else handler(gui, value)
+        if notify_monitor:
+            await notify_monitor('-', self.session, None)        
+        return result
+
     @property
     def blocks(self):
         return [self.active_dialog] if self.active_dialog and \
@@ -188,8 +219,7 @@ class User:
                 raw = Message(*raw, user = self)
         return raw
 
-    async def process(self, message):
-        self.last_message = message     
+    async def process(self, message):        
         screen_change_message = getattr(message, 'screen',None) and self.screen.name != message.screen
         if is_screen_switch(message) or screen_change_message:
             for s in self.screens:
@@ -214,18 +244,16 @@ class User:
         return Error(error)
         
     async def process_element(self, elem, message):                
-        event = message.event        
+        event = message.event 
         query = event == 'complete' or event == 'append'
         
         handler = self.__handlers__.get((elem, event), None)
         if handler:
-            return (await handler(elem, message.value)) if asyncio.iscoroutinefunction(handler)\
-                  else handler(elem, message.value)              
+            return await self.eval_handler(handler, elem, message.value)
             
         handler = getattr(elem, event, False)                                
         if handler:                
-            result = (await handler(elem, message.value)) if asyncio.iscoroutinefunction(handler)\
-                  else handler(elem, message.value) 
+            result = await self.eval_handler(handler, elem, message.value)
             if query:                        
                 result = Answer(event, message, result)                
             return result
@@ -235,14 +263,27 @@ class User:
             error = f"{message.block}/{message.element} doesn't contain '{event}' method type!"
             self.log(error)                     
             return Error(error)
+        
+    def monitor(self, session, share):
+        if config.share and session != testdir:
+            self.log(f'User is connected, session: {session}, share: {share.session if share else None}', type = 'info')            
+
+    def sync_send(self, obj):                    
+        asyncio.run(self.send(obj))
     
     def log(self, str, type = 'error'):        
         scr = self.screen.name if self.screens else 'void'
         str = f"session: {self.session}, screen: {scr}, message: {self.last_message}\n  {str}"
-        if type == 'error':
-            logging.error(str)
-        else:
-            logging.warning(str)    
+        with logging_lock:
+            if type == 'error':
+                logging.error(str)
+            elif type == 'warning':
+                logging.warning(str)    
+            else:
+                func = logging.getLogger().setLevel
+                func(level = logging.INFO)
+                logging.info(str)
+                func(level = logging.WARNING)
 
 User.type = User
 User.last_user = None
@@ -250,15 +291,22 @@ User.toolbar = []
 User.sessions = {}
 User.count = 0
 
+def context_user():
+    return context_object(User)
+
+def context_screen():
+    user = context_user()
+    return user.screen if user else None
+
 def make_user(request):
     session = f'{request.remote}-{User.count}'
     User.count += 1    
-    requested_connect = request.headers.get('session')
-    if requested_connect:
+    if requested_connect := request.query_string if config.share else None:
         user = User.sessions.get(requested_connect, None)
         if not user:
             error = f'Session id "{requested_connect}" is unknown. Connection refused!'
-            logging.error(error)
+            with logging_lock:
+                logging.error(error)
             return None, Error(error)
         user = User.type(session, user)
         ok = user.screens

unisi/utils.py

@@ -1,10 +1,11 @@
-import os, platform, requests
+import os, platform, requests, inspect, logging
 
 blocks_dir = 'blocks'        
 screens_dir =  'screens'        
 UpdateScreen = True
 Redesign = 2
 public_dirs = 'public_dirs'
+testdir = 'autotest'
 
 divpath = '\\' if platform.system() == 'Windows' else '/'
 libpath = os.path.dirname(os.path.realpath(__file__))
@@ -26,6 +27,42 @@ appname = 'Unisi app'
     import config
     print("Config with default parameters is created!")
 
+#setting config variables
+defaults = {
+    testdir: False,
+    'appname' : 'Unisi app',
+    'upload_dir' : 'web',
+    'logfile': None,
+    'hot_reload' : False,    
+    'mirror' : False,
+    'share' : False,
+    'profile' : 0, 
+    'llm' : None,
+    'froze_time': None,
+    'monitor_tick' : 0.005,
+    'pool' : None
+}
+for param, value in defaults.items():
+    if not hasattr(config, param):
+       setattr(config, param, value)
+
+if config.froze_time == 0:
+    print('froze_time in config.py can not be 0!')
+    config.froze_time = None
+
+def context_object(target_type):
+  """
+  Finds the first argument of a specific type in the current function call stack.
+  """  
+  frame = inspect.currentframe()
+  while frame:    
+    args, _, _, values = inspect.getargvalues(frame)    
+    if args and isinstance(values[args[0]], target_type):
+      return values[args[0]]
+    # Move to the previous frame in the call stack
+    frame = frame.f_back
+  return None
+
 def is_screen_switch(message):
     return message and message.block == 'root' and message.element is None
 
@@ -105,4 +142,13 @@ def Answer(type, message, result):
     ms.message = message
     return ms
 
+def 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)    
+
+start_logging()
+
+
 

unisi/web/css/{662.64dbc68c.css → 493.824522cf.css}

@@ -1 +1 @@
-thead tr:first-child th{-webkit-backdrop-filter:blur(10px);backdrop-filter:blur(10px);position:sticky;top:0;z-index:1000}:root{--scrollbar-width-height:10px;--scrollbar-thumb-hover:#2176d2;--scrollbar-thumb-dark:#2176d2;--scrollbar-thumb-hover-dark:#2176d2}::-webkit-scrollbar{height:var(--scrollbar-width-height);width:var(--scrollbar-width-height)}::-webkit-scrollbar-track{box-shadow:inset 0 0 4px var(--scrollbar-track-dark)}::-webkit-scrollbar-corner{background:var(--scrollbar-track-dark)}::-webkit-scrollbar-thumb{background:var(--scrollbar-thumb-dark);border-radius:5px}::-webkit-scrollbar-thumb:hover{background:var(--scrollbar-thumb-hover-dark)}body[data-v-f48596a0]{display:flex;justify-content:center}.custom-caption[data-v-f48596a0]{padding:5px!important}.web-camera-container[data-v-f48596a0]{align-items:center;border:1px solid #ccc;border-radius:4px;display:flex;flex-direction:column;justify-content:center;margin-bottom:2rem;margin-top:2rem;padding:2rem;width:500px}.web-camera-container .camera-button[data-v-f48596a0]{margin-bottom:2rem}.web-camera-container .camera-box .camera-shutter[data-v-f48596a0]{background-color:#fff;height:337.5px;opacity:0;position:absolute;width:450px}.web-camera-container .camera-box .camera-shutter.flash[data-v-f48596a0]{opacity:1}.web-camera-container .camera-shoot[data-v-f48596a0]{margin:1rem 0}.web-camera-container .camera-shoot button[data-v-f48596a0]{align-items:center;border-radius:100%;display:flex;height:60px;justify-content:center;width:60px}.web-camera-container .camera-shoot button img[data-v-f48596a0]{height:35px;object-fit:cover}.web-camera-container .camera-loading[data-v-f48596a0]{height:100%;margin:3rem 0 0 -1.2rem;min-height:150px;overflow:hidden;position:absolute;width:100%}.web-camera-container .camera-loading ul[data-v-f48596a0]{height:100%;margin:0;position:absolute;width:100%;z-index:999999}.web-camera-container .camera-loading .loader-circle[data-v-f48596a0]{display:block;height:14px;left:100%;margin:0 auto;padding:0;position:absolute;top:50%;transform:translateY(-50%);transform:translateX(-50%);width:100%}.web-camera-container .camera-loading .loader-circle li[data-v-f48596a0]{animation:preload-f48596a0 1s infinite;background:#999;border-radius:100%;display:block;float:left;height:10px;line-height:10px;margin:0 0 0 4px;padding:0;position:relative;top:-50%;width:10px}.web-camera-container .camera-loading .loader-circle li[data-v-f48596a0]:nth-child(2){animation-delay:.2s}.web-camera-container .camera-loading .loader-circle li[data-v-f48596a0]:nth-child(3){animation-delay:.4s}@keyframes preload-f48596a0{0%{opacity:1}50%{opacity:.4}to{opacity:1}}.q-tab__label{font-size:16px;font-weight:700}
+thead tr:first-child th{-webkit-backdrop-filter:blur(10px);backdrop-filter:blur(10px);position:sticky;top:0;z-index:1000}:root{--scrollbar-width-height:10px;--scrollbar-thumb-hover:#2176d2;--scrollbar-thumb-dark:#2176d2;--scrollbar-thumb-hover-dark:#2176d2}::-webkit-scrollbar{height:var(--scrollbar-width-height);width:var(--scrollbar-width-height)}::-webkit-scrollbar-track{box-shadow:inset 0 0 4px var(--scrollbar-track-dark)}::-webkit-scrollbar-corner{background:var(--scrollbar-track-dark)}::-webkit-scrollbar-thumb{background:var(--scrollbar-thumb-dark);border-radius:5px}::-webkit-scrollbar-thumb:hover{background:var(--scrollbar-thumb-hover-dark)}body[data-v-6eb6b02a]{display:flex;justify-content:center}.custom-caption[data-v-6eb6b02a]{padding:5px!important}.web-camera-container[data-v-6eb6b02a]{align-items:center;border:1px solid #ccc;border-radius:4px;display:flex;flex-direction:column;justify-content:center;margin-bottom:2rem;margin-top:2rem;padding:2rem;width:500px}.web-camera-container .camera-button[data-v-6eb6b02a]{margin-bottom:2rem}.web-camera-container .camera-box .camera-shutter[data-v-6eb6b02a]{background-color:#fff;height:337.5px;opacity:0;position:absolute;width:450px}.web-camera-container .camera-box .camera-shutter.flash[data-v-6eb6b02a]{opacity:1}.web-camera-container .camera-shoot[data-v-6eb6b02a]{margin:1rem 0}.web-camera-container .camera-shoot button[data-v-6eb6b02a]{align-items:center;border-radius:100%;display:flex;height:60px;justify-content:center;width:60px}.web-camera-container .camera-shoot button img[data-v-6eb6b02a]{height:35px;object-fit:cover}.web-camera-container .camera-loading[data-v-6eb6b02a]{height:100%;margin:3rem 0 0 -1.2rem;min-height:150px;overflow:hidden;position:absolute;width:100%}.web-camera-container .camera-loading ul[data-v-6eb6b02a]{height:100%;margin:0;position:absolute;width:100%;z-index:999999}.web-camera-container .camera-loading .loader-circle[data-v-6eb6b02a]{display:block;height:14px;left:100%;margin:0 auto;padding:0;position:absolute;top:50%;transform:translateY(-50%);transform:translateX(-50%);width:100%}.web-camera-container .camera-loading .loader-circle li[data-v-6eb6b02a]{animation:preload-6eb6b02a 1s infinite;background:#999;border-radius:100%;display:block;float:left;height:10px;line-height:10px;margin:0 0 0 4px;padding:0;position:relative;top:-50%;width:10px}.web-camera-container .camera-loading .loader-circle li[data-v-6eb6b02a]:nth-child(2){animation-delay:.2s}.web-camera-container .camera-loading .loader-circle li[data-v-6eb6b02a]:nth-child(3){animation-delay:.4s}@keyframes preload-6eb6b02a{0%{opacity:1}50%{opacity:.4}to{opacity:1}}.q-tab__label{font-size:16px;font-weight:700}

unisi/web/index.html

@@ -1 +1 @@
-<!DOCTYPE html><html><head><title>UNISI</title><meta charset=utf-8><meta name=description content="UNISI on Quasar"><meta name=format-detection content="telephone=no"><meta name=msapplication-tap-highlight content=no><meta name=viewport content="user-scalable=no,initial-scale=1,maximum-scale=1,minimum-scale=1,width=device-width"><link rel=icon type=image/png sizes=128x128 href=icons/favicon-128x128.png><link rel=icon type=image/png sizes=96x96 href=icons/favicon-96x96.png><link rel=icon type=image/png sizes=32x32 href=icons/favicon-32x32.png><link rel=icon type=image/png sizes=16x16 href=icons/favicon-16x16.png><link rel=icon type=image/ico href=favicon.ico><script defer src=js/vendor.d6797c01.js></script><script defer src=js/app.636fcf8d.js></script><link href=css/vendor.9ed7638d.css rel=stylesheet><link href=css/app.31d6cfe0.css rel=stylesheet></head><body><div id=q-app></div></body></html>
+<!DOCTYPE html><html><head><base href=/ ><title>UNISI</title><meta charset=utf-8><meta name=description content="UNISI on Quasar"><meta name=format-detection content="telephone=no"><meta name=msapplication-tap-highlight content=no><meta name=viewport content="user-scalable=no,initial-scale=1,maximum-scale=1,minimum-scale=1,width=device-width"><link rel=icon type=image/png sizes=128x128 href=icons/favicon-128x128.png><link rel=icon type=image/png sizes=96x96 href=icons/favicon-96x96.png><link rel=icon type=image/png sizes=32x32 href=icons/favicon-32x32.png><link rel=icon type=image/png sizes=16x16 href=icons/favicon-16x16.png><link rel=icon type=image/ico href=favicon.ico><script defer src=/js/vendor.eab68489.js></script><script defer src=/js/app.cf197a5a.js></script><link href=/css/vendor.9ed7638d.css rel=stylesheet><link href=/css/app.31d6cfe0.css rel=stylesheet></head><body><div id=q-app></div></body></html>