unisi 0.1.11__py3-none-any.whl → 0.1.12__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,116 @@
+import multiprocessing, time, asyncio, logging
+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
+
+# Define an asynchronous function that will run the synchronous function in a separate process
+""" argument example
+def long_running_task(queue):
+    for i in range(5):
+        time.sleep(2)  # emulate long calculation
+        queue.put(f"Task is {i*20}% complete")
+    queue.put(None)
+
+async def callback(string):
+    await context_user().progress(str)
+"""
+async def run_external_process(long_running_task, *args, callback = False):
+    if callback:
+        queue = multiprocessing.Manager().Queue()    
+        args = *args, queue
+    result = multiprocessing_pool().apply_async(long_running_task, args)
+    if callback:
+        while not result.ready():
+            if not queue.empty():
+                message = queue.get()
+                if message is None:
+                    break
+                await callback(message)
+            await asyncio.sleep(0.1)  
+    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/server.py

@@ -80,31 +80,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)        
+        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,21 @@ 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, callback = False):
+        if callback and notify_monitor and callback != self.progress: #progress notifies the monitor
+            async def new_callback(value):
+                asyncio.gather(notify_monitor('e', self.session, self.last_message), callback(value))                
+            callback = new_callback
+        return await run_external_process(long_running_task, *args, callback = callback)
 
     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 +52,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 +76,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 +88,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 +122,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 +138,7 @@ class User:
 
     @property
     def testing(self):        
-        return  self.session == 'autotest'
+        return  self.session == testdir
     
     @property
     def screen(self):        
@@ -125,16 +148,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 +166,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 +218,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 +243,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 +262,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 +290,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.headers.get('session') 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,41 @@ 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, 
+    'rag' : 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)
+#froze_time can not be 0
+if config.froze_time == 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 +141,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-0.1.11.dist-info → unisi-0.1.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unisi
-Version: 0.1.11
+Version: 0.1.12
 Summary: Unified System Interface, GUI and Remote API
 Author-Email: UNISI Tech <g.dernovoy@gmail.com>
 License: Apache-2.0
@@ -16,7 +16,7 @@ Requires-Dist: websocket-client
 Description-Content-Type: text/markdown
 
 # UNISI #
-UNified System Interface and GUI
+UNified System Interface, GUI and Remote API
 
 ### Purpose ###
 UNISI technology provides a unified system interface and advanced program functionality, eliminating the need for front-end and most back-end programming. It automates common tasks, as well as unique ones, significantly reducing the necessity for manual programming and effort.
@@ -31,6 +31,7 @@ UNISI technology provides a unified system interface and advanced program functi
  - Integral autotesting
  - Protocol schema auto validation
  - Shared sessions
+ - Monitoring and profiling
 
 ### Installing ###
 ```
@@ -92,10 +93,13 @@ Connect a browser to localhast:8000 which are by default and will see:
 ### Handling events ###
 All handlers are functions which have a signature
 ```
-def handler_x(gui_object, value_x)
+def handler_x(gui_object, value_x) #or
+async def handler_x(gui_object, value_x)
 ```
 where gui_object is a Python object the user interacted with and value for the event.
 
+#### UNISI supports synchronous and asynchronous handlers automatically adopting them for using. ####
+
 All Gui objects except Button have a field ‘value’. 
 For an edit field the value is a string or number, for a switch or check button the value is boolean, for table is row id or index, e.t.c.
 When a user changes the value of the Gui object or presses Button, the server calls the ‘changed’ function handler.
@@ -113,10 +117,9 @@ clean_button = Button('Clean the table’, clean_table)
 | Gui object array or tuple |  Objects to update |
 | None | Nothing to update, Ok |
 | Error(...), Warning(...), Info(...) | Show to user info about a state. |
-| True | Redraw whole screen |
-
+| True | Update whole screen |
+| Redesign | Update and redesign whole screen |
 | Dialog(..) | Open a dialog with parameters |
-| user.set_screen(screen_name) | switch to another screen |
 
 Unisi synchronizes GUI state on frontend-end automatically after calling a handler.
 
@@ -408,16 +411,16 @@ Error(error_message, *someGUIforUpdades)
 ```
 They are returned by handlers and cause appearing on the top screen colored rectangles window for 3 second. someGUIforUpdades is optional GUI enumeration for updating.
 
-For long time processes it is possible to create Progress window. It is just call user.progress in any place.
+For long time processes it is possible to create Progress window. It is just call user.progress in any async handler.
 Open window 
 ```
-user.progress("Analyze .. Wait..")
+await user.progress("Analyze .. Wait..")
 ```
 Update window message 
 ```
-user.progress(" 1% is done..")
+await user.progress(" 1% is done..")
 ```
-Progree window is automatically closed when the handler is finished.
+Progress window is automatically closed when the handler is finished.
 
 ### Milti-user support. ###
 Unisi automatically creates and serves an environment for every user.

{unisi-0.1.11.dist-info → unisi-0.1.12.dist-info}/RECORD

@@ -1,22 +1,23 @@
-unisi-0.1.11.dist-info/METADATA,sha256=jZe5qOclohUz6WKqpAxwXDXNRxyolhto6eBrHcGnh5I,21428
-unisi-0.1.11.dist-info/WHEEL,sha256=N2J68yzZqJh3mI_Wg92rwhw0rtJDFpZj9bwQIMJgaVg,90
-unisi-0.1.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-unisi/__init__.py,sha256=bQ7yTDcgybkbIGTjxkajTbBJXtgyryrCvt3nXg8QxlQ,175
-unisi/autotest.py,sha256=QHNVBD4sMx9cn94RIbwQhwuX9H72hB69pZwS7yqhiZw,9487
-unisi/common.py,sha256=tdvHvEgZ5vzvLVjGGGIeZq5xHBYNBOydKjzDWoZWCSA,643
-unisi/containers.py,sha256=Me28aZkhchWJA5OExtXoFzl2u5bc6p0m2Cww7CfKIbA,4200
-unisi/guielements.py,sha256=svPMIEMbhW5uH4jz5rsjTeVVFl_P7VrMniTFFQvpmzs,5998
+unisi-0.1.12.dist-info/METADATA,sha256=qUwdMcBAUP61NnJq4uu87ynQgTfsnMJdBHPnnttD_vM,21624
+unisi-0.1.12.dist-info/WHEEL,sha256=7sv5iXvIiTVJSnAxCz2tGBm9DHsb2vPSzeYeT7pvGUY,90
+unisi-0.1.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+unisi/__init__.py,sha256=ZG79jkpNc3wvOYbO058Jh850ozD4rswMuPXwVPvcKy8,205
+unisi/autotest.py,sha256=oYDYRc5gF01lYF2q1a8EFjz0pz9IsedLmG_9Y1op2_A,8731
+unisi/common.py,sha256=D1khg0Dkvyn3Zi9bK2ZZQpjXmvOotNGDjJdzRiwZ6XY,624
+unisi/containers.py,sha256=gY6oV3Wz35CZ7vrlEvfJVsTuJ3bgGAqLFItkX2Oiiuo,4165
+unisi/guielements.py,sha256=d8g5UKPmqGIDwVRhikTrSW3NvysMqI3R4ti0BeHf5Oo,5955
 unisi/jsoncomparison/__init__.py,sha256=lsWkYEuL6v3Qol-lwSUvB6y63tm6AKcCMUd4DZDx3Cg,350
 unisi/jsoncomparison/compare.py,sha256=qPDaxd9n0GgiNd2SgrcRWvRDoXGg7NStViP9PHk2tlQ,6152
 unisi/jsoncomparison/config.py,sha256=LbdLJE1KIebFq_tX7zcERhPvopKhnzcTqMCnS3jN124,381
 unisi/jsoncomparison/errors.py,sha256=wqphE1Xn7K6n16uvUhDC45m2BxbsMUhIF2olPbhqf4o,1192
 unisi/jsoncomparison/ignore.py,sha256=xfF0a_BBEyGdZBoq-ovpCpawgcX8SRwwp7IrGnu1c2w,2634
+unisi/multimon.py,sha256=NJhSXmLp1fnDuaAa6-PCUSPCEjl_vf6TFfQRLQHklFI,4200
 unisi/proxy.py,sha256=meZ4-26KXefuaZ04Gfrexij7rreBPKLPJSwPCIqftx0,7660
 unisi/reloader.py,sha256=B0f9GU452epFvdih8sH7_NiIJrXnC5i27uw2imGQxMg,6585
-unisi/server.py,sha256=UKRm6ZUQb9gvlRMdH6EWtfih3B00uSvKGNj3QNl8TAw,4979
+unisi/server.py,sha256=tAbDjVqOHRbRVR2JcSt--ctuywKduWiOOCHJwIFSa7M,4118
 unisi/tables.py,sha256=v7Fio5iIN7u1t7cE4Yvl4ewn7jTmmNPyWigoKW1Mj8U,4239
-unisi/users.py,sha256=dYNOx5X1Yvj6475zqqVKQjyAe1pHtKvm_rz_7Qgnp0Y,11100
-unisi/utils.py,sha256=hxwCCPZla1iSz9Y1CseDpE5K5JOdOyDlXtXuxpEAviw,2987
+unisi/users.py,sha256=tznpwkmTb89EtZe86t_nPgACAnwjcrFKg7nPt9qHd2U,13117
+unisi/utils.py,sha256=Sxu3kpIpddsVLUjz2c0GjxwyehV6qGkX1u8kyueLtLo,4260
 unisi/web/css/662.64dbc68c.css,sha256=ckeNz4l2QkIp60LdV_-cEXf9orp0ZVklEbrQfjkAG5M,2691
 unisi/web/css/app.31d6cfe0.css,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 unisi/web/css/vendor.9ed7638d.css,sha256=p_6HvcTaHu2zmOmfGxEGiGu5TIFZ75_XKHJZWA0eGCE,220597
@@ -39,4 +40,4 @@ unisi/web/js/430.591e9a73.js,sha256=7S1CJTwGdE2EKXzeFRcaYuTrn0QteoVI03Hykz8qh3s,
 unisi/web/js/662.5957b792.js,sha256=9zsZsZXeiTYgvB6RbF7guuqOXcb5DAQp31Djl52Y-ow,56727
 unisi/web/js/app.636fcf8d.js,sha256=THmpgdBjzB_6O3LqK0biyFfeqKg3UNwP32R7Tu7oifE,5923
 unisi/web/js/vendor.d6797c01.js,sha256=2aKM3Lfxc0pHSirrcUReL1LcvDYWnfeBj2c67XsSELk,1279477
-unisi-0.1.11.dist-info/RECORD,,
+unisi-0.1.12.dist-info/RECORD,,

{unisi-0.1.11.dist-info → unisi-0.1.12.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: pdm-backend (2.1.8)
+Generator: pdm-backend (2.2.1)
 Root-Is-Purelib: true
 Tag: py3-none-any