unisi 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

unisi/autotest.py

@@ -202,9 +202,8 @@ def check_module(module):
 def run_tests():
     if not os.path.exists(testdir):
         os.makedirs(testdir)
-    user = User.UserType()
-    user.load()
-    user.session = 'autotest'
+    user = User.UserType('autotest')
+    user.load()    
     errors = []
     for module in user.screens:
         errors += check_module(module)

unisi/proxy.py

@@ -26,11 +26,11 @@ message_types = ['error','warning','info']
 
 class Proxy:
     """UNISI proxy"""
-    def __init__(self, host_port, timeout = 7, ssl = False):
+    def __init__(self, host_port, timeout = 7, ssl = False, session = ''):
         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)
+        self.conn = create_connection(addr_port, timeout = timeout, header = {'session' : session})
         self.screen = None       
         self.screens = {}
         self.dialog = None

unisi/server.py

@@ -44,60 +44,70 @@ async def static_serve(request):
      
 def broadcast(message, message_user):
     screen = message_user.screen_module
-    for user in User.reflections:
+    for user in message_user.reflections:
         if user is not message_user and screen is user.screen_module:
             user.sync_send(message)
-
+import gc
 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          
+    user, status = make_user(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))        
-        await ws.send_str(res)        
+        async def send(res):
+            if type(res) != str:
+                res = toJson(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)
-                    message = None
-                    if isinstance(raw_message, list):
-                        if raw_message:
-                            for raw_submessage in raw_message:
-                                message = ReceivedMessage(raw_submessage)                    
-                                result = user.result4message(message)
-                        else:                                
-                            result = Warning('Empty command batch!')
-                    else:                    
-                        message = ReceivedMessage(raw_message)            
-                        result = user.result4message(message)                    
-                    await send(result)
-                    if message:
-                        if recorder.record_file:
-                            recorder.accept(message, user.prepare_result (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(toJson(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())
+        user.send = send         
+        await send(user.screen if status 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)
+                        message = None
+                        if isinstance(raw_message, list):
+                            if raw_message:
+                                for raw_submessage in raw_message:
+                                    message = ReceivedMessage(raw_submessage)                    
+                                    result = user.result4message(message)
+                            else:                                
+                                result = Warning('Empty command batch!')
+                        else:                    
+                            message = ReceivedMessage(raw_message)            
+                            result = user.result4message(message)                    
+                        await send(result)
+                        if message:
+                            if recorder.record_file:
+                                recorder.accept(message, user.prepare_result (result))
+                            if user.reflections 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(toJson(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       
+        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)
+        gc.collect()
+    return ws  #?<->     
 
 def start(appname = None, user_type = User, http_handlers = []):    
     if appname is not None:

unisi/users.py

@@ -9,14 +9,27 @@ 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   
+    def __init__(self, session: str, share = None):          
+        self.session = session        
+        self.active_dialog = None        
+        self.last_message = None                       
+        User.last_user = self
+
+        if share:            
+            self.screens = share.screens            
+            self.screen_module = share.screen_module if share.screens else []
+            self.__handlers__ =  share.__handlers__        
+            
+            if share.reflections:            
+                share.reflections.append(self)
+            else:
+                share.reflections = [share, self]                    
+            self.reflections = share.reflections
+        else:
+            self.screens = []        
+            self.reflections = []
+            self.screen_module = None         
+            self.__handlers__ = {}              
 
     async def send_windows(self, obj):  
         await self.send(obj)        
@@ -218,32 +231,34 @@ class User:
         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'
+        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)    
 
-def make_user():
-    if config.mirror and User.last_user:
-        user = User.last_user.reflect()
+def make_user(request):
+    session = f'{request.remote}-{User.count}'
+    User.count += 1    
+    requested_connect = request.headers.get('session', '')
+    if requested_connect:
+        user = User.sessions.get(requested_connect, None)
+        if not user:
+            error = f'Session id "{requested_connect}" is unknown. Connection refused!'
+            logging.error(error)
+            return None, Error(error)
+        user = User.UserType(session, user)
+        ok = user.screens
+    elif config.mirror and User.last_user:
+        user = User.UserType(session, User.last_user)
         ok = user.screens
     else:
-        user = User.UserType()
-        ok = user.load()
-    if config.mirror:
-        User.reflections.append(user)         
+        user = User.UserType(session)
+        ok = user.load()       
+    User.sessions[session] = user 
     return user, ok
 
 #loop and thread is for progress window and sync interactions
@@ -265,4 +280,5 @@ User.extra_loop = loop
 User.UserType = User
 User.last_user = None
 User.toolbar = []
-User.reflections = []
+User.sessions = {}
+User.count = 0

{unisi-0.1.9.dist-info → unisi-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unisi
-Version: 0.1.9
+Version: 0.1.10
 Summary: Unified System Interface, GUI and Remote API
 Author-Email: UNISI Tech <g.dernovoy@gmail.com>
 License: Apache-2.0
@@ -84,7 +84,10 @@ unisi.start('Test app')
 Unisi builds the interactive app for the code above.
 Connect a browser to localhast:8000 which are by default and will see:
 
-![image](https://github.com/unisi-tech/unisi/assets/1247062/dafebd1f-ae48-4790-9282-dea83d986749)
+![image](https://github.com/unisi-tech/unisi/assets/1247062/dafebd1f-ae48-4790-9282-dea83d986749)  
+
+### 'The fastest way to create Web applications in Python.' is a free crash course video how to use UNISI ###
+   https://www.unisi.tech/learn
 
 ### Handling events ###
 All handlers are functions which have a signature
@@ -110,25 +113,37 @@ 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. |
-| UpdateScreen, True | Redraw whole screen |
+| True | Redraw 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.
+Unisi synchronizes GUI state on frontend-end automatically after calling a handler.
 
 If a Gui object doesn't have 'changed' handler the object accepts incoming value automatically to the 'value' variable of gui object.
 
 If 'value' is not acceptable instead of returning an object possible to return Error or Warning or Info. That functions can update a object list passed after the message argument.
 
 ```
-def changed_range(guirange, value):
-   if value < 0.5 and value > 1.0:       
-       return Error(f‘The value of {guirange.name} has to be > 0.5 and < 1.0!', guirange) 
+def changed(elem, value):
+   if value == 4:       
+       return Error(f‘The value can not be 4!', elem) 
     #accept value othewise
-    guirange.value = value
+    elem.value = value
 
-edit = Edit('Range of involving', 0.6, changed_range, type = 'number')
+edit = Edit('Involving', 0.6, changed)
+```
+
+#### Events interception of shared blocks ####
+Interception handlers have the same in/out format as usual handlers.
+#### They are called before the inner element handler call. They cancel the call of inner element handler but you can call it as shown below.
+For example above interception of select_mode changed event will be:
+```
+@handle(select_mode, 'changed')
+def do_not_select_mode_x(selector, value):
+    if value == 'Mode X':
+        return Error('Do not select Mode X in this context', selector) # send old value for update select_mode to the previous state
+    return _.accept(value) #otherwise accept the value
 ```
 
 ### Block details ###
@@ -159,18 +174,6 @@ from blocks.tblock import concept_block
 blocks = [.., concept_block]
 ```
 
-#### Events interception of shared elements ####
-Interception handlers have the same in/out format as usual handlers.
-#### They are called before the inner element handler call. They cancel the call of inner element handler but you can call it as shown below.
-For example above interception of select_mode changed event will be:
-```
-@handle(select_mode, 'changed')
-def do_not_select_mode_x(selector, value):
-    if value == 'Mode X':
-        return Error('Do not select Mode X in this context', selector) # send old value for update select_mode to the previous state
-    return _.accept(value) #otherwise accept the value
-```
-
 #### Layout of blocks. #### 
 If the blocks are simply listed Unisi draws them from left to right or from top to bottom depending on the orientation setting. If a different layout is needed, it can be set according to the following rule: if the vertical area must contain more than one block, then the enumeration in the array will arrange the elements vertically one after another. If such an element enumeration is an array of blocks, then they will be drawn horizontally in the corresponding area.
 
@@ -180,6 +183,24 @@ blocks = [ [b1,b2], [b3, [b4, b5]]]
 
 ![image](https://github.com/unisi-tech/unisi/assets/1247062/aa0c3623-ef57-45ce-a179-7ba53df119c3)
 
+### ParamBlock ###
+ParamBlock(name, *gui_elements, row = 3, **parameters)
+
+ParamBlock creates blocks with Gui elements formed from parameters. Parameters can be string, bool, number and optional types. Example:
+```
+block = ParamBlock('Learning parameters', Button('Start learning', learn_nn)
+    per_device_eval_batch_size=16, num_train_epochs=10, warmup_ratio=0.1, 
+    logging_steps=10, device = (‘cpu’,['cpu', 'gpu']),load_best = True)
+```
+
+If a string parameter has several options as a device in the example, its value is expressed as an option list and the first value is the initial value.
+For optional types Select, Tree, Range the value has to contain the current value and its options. In the example
+```
+device = (‘cpu’,['cpu', 'gpu'])
+```
+means the current value of 'device' is 'cpu' and options are ['cpu', 'gpu'] .
+
+
 ### Basic gui elements ###
 Normally they have type property which says unisi what data it contains and optionally how to draw the element. 
 #### If the element name starts from _ , unisi will hide its name on the screen. ####
@@ -200,34 +221,34 @@ causes  a call changed handler if it defined, otherwise just save value to self.
 ### Button ###
 Normal button.
 ```
-Button('Push me', changed = push_callback) 
+Button('Push me', changed = push_callback, icon = None) 
 ```
 Short form
 ```
-Button('Push me', push_callback) 
+Button('Push me', push_callback = None, icon = None) 
 ```
-Icon button 
+Icon button, the name has to be started from _ for hiding 
 ```
-Button('_Check', push_callback, icon = 'check')
+Button('_Check', push_callback = None, icon = None)
 ```
 
 ### Load to server Button ###
 Special button provides file loading from user device or computer to the Unisi server.
 ```
-UploadButton('Load', handler_when_loading_finish, icon='photo_library')
+UploadButton('Load', handler_when_loading_finish, icon = 'photo_library')
 ```
 handler_when_loading_finish(button_, the_loaded_file_filename) where the_loaded_file_filename is a file name in upload server folder. This folder name is defined in config.py .
 
 ### Edit and Text field. ###
 ```
-Edit('Some field', '') #for string value
-Edit('Number field', 0.9, type = 'number') #changed handler will get a number
+Edit(name,value = '', changed_handler = None) #for string value
+Edit(name, value: number, changed_handler = None) #changed handler gets a number in the value parameter
 ```
-If set edit = false it will be readonly field.
+If set edit = false the element will be readonly.
 ```
 Edit('Some field', '', edit = false) 
-#text
-Text('Some text')
+#text, it is equal
+Text('Some field')
 ```
 complete handler is optional function which accepts the current edit value and returns a string list for autocomplete.
 
@@ -241,23 +262,30 @@ Edit('Edit me', 'value', complete = get_complete_list) #value has to be string o
 Optional 'update' handler is called when the user press Enter in the field.
 It can return None if OK or objects for updating as usual 'changed' handler.
 
-Optional selection property with parameters (start, end) is called when selection is happened.
-Optional autogrow property uses for serving multiline fileds.
+### Range ###
+Number field for limited in range values.
+
+Range('Name',  value = 0,  changed_handler = None, options=[min,max, step])
+
+Example:  
+```
+Range('Scale content',  1, options=[0.25, 3, 0.25])
+```
 
 
 ### Radio button ###
 ```
-Switch(name, value, changed, type = ...)
-value is boolean, changed is an optional handler.
+Switch(name, value = False, changed_handler = None, type = 'radio')
+value is boolean, changed_handler is an optional handler.
 Optional type can be 'check' for a status button or 'switch' for a switcher . 
 ```
 
 ### Select group. Contains options field. ###
 ```
-Select('Select something', "choice1", selection_is_changed, options = ["choice1","choice2", "choice3"]) 
+Select(name, value = None, changed_handler = None, options = ["choice1","choice2", "choice3"]) 
 ```
-Optional type parameter can be 'toggles','list','dropdown'. Unisi automatically chooses between toogles and dropdown, if type is omitted,
-if type = 'list' then Unisi build it as vertical select list.
+Optional type parameter can be 'radio','list','select'. Unisi automatically chooses between 'radio' and 'select', if type is omitted.
+If type = 'list' then Unisi build it as vertical select list.
 
 
 ### Image. ###
@@ -265,28 +293,30 @@ width,changed,height,header are optional, changed is called if the user select o
 When the user click the image, a check mark is appearing on the image, showning select status of the image.
 It is usefull for image list, gallery, e.t.c
 ```
-Image(image_name, selecting_changed, header = 'description',url = ...,  width = .., height = ..)
+Image(image_path, value = False, changed_handler, header = 'description', url = ...,  width = .., height = ..)
 ```
 
 ### Video. ###
 width and height are optional.
 ```
-Video(video_url, width = .., height = ..)
+Video(video_url, width = None, height = None)
 ```
 
 ### Tree. The element for tree-like data. ###
 ```
-Tree(name, selected_item_name, changed_handler, options = {name1: parent1, name2 : None, .})
+Tree(name, value = None, changed_handler = None, options = {name1: parent1, name2 : None, .})
 ```
 options is a tree structure, a dictionary {item_name:parent_name}. 
 parent_name is None for root items. changed_handler gets item key (name) as value. 
 
 ### Table. ###
 Tables is common structure for presenting 2D data and charts. 
-Optional append, delete, update handlers are called for adding, deleting and updating rows.
 
+Table(name, value = None, changed_handler = None, **options)
+
+Optional append, delete, update handlers are called for adding, deleting and updating handlers for a table.
 
-Assigning a handler for such action causes Unii to draw and activate an appropriate action icon button in the table header automatically.
+Auto assigning handlers for such action can be blocked by assigning edit  = False to the Table constructor.
 ```
 table = Table('Videos', [0], row_changed, headers = ['Video', 'Duration', 'Owner', 'Status'],  
   rows = [
@@ -315,7 +345,6 @@ value = [0] means 0 row is selected in multiselect mode (in array). multimode is
 ### Table handlers. ###
 complete, modify and update have the same format as the others handlers, but value is consisted from the cell value and its position in the table.
 
-
 ```
 def table_updated(table_, tabval):
     value, position = tabval
@@ -323,6 +352,7 @@ def table_updated(table_, tabval):
     ...
     if error_found:
         return Error('Can not accept the value!')
+    #call a standart handler
     accept_rowvalue(table_, tabval)
 ```
 
@@ -333,45 +363,40 @@ Chart is a table with additional Table constructor parameter 'view' which explai
 ### Graph ###
 Graph supports an interactive graph.
 ```
-graph = Graph('X graph', graph_value, graph_selection, 
-    nodes = [
-     { 'id' : 'node1', 'name': "Node 1" },
-     { 'id' : 'node2', 'name': "Node 2" },
-     { 'id' : 'node3', 'name': "Node 3" }    
-  ], edges = [
-     { 'id' : 'edge1', 'source': "node1", 'target': "node2", 'name' : 'extending' },
-     { 'id' :'edge2' , 'source': "node2", 'target': "node3" , 'name' : 'extending'}     
-  ])
-```
-where graph_value is a dictionary like {'nodes' : ["node1"], 'edges' : ['edge3']}, where enumerations are selected nodes and edges.
+graph = Graph('X graph', value = None, changed_handler = None, 
+    nodes = [ Node("Node 1"),Node("Node 2", size = 20),None, Node("Node 3", color = "#3CA072")],
+    edges = [ Edge(0,1, color = "#3CA072"), Edge(1,3,'extending', size = 6),Edge(3,4, size = 2), Edge(2,4)]])
+```
+where value is None or a dictionary like {'nodes' : [id1, ..], 'edges' : [id2, ..]}, where enumerations are selected nodes and edges.
 Constant graph_default_value == {'nodes' : [], 'edges' : []} i.e. nothing to select.
 
-'changed' method graph_selector called when user (de)selected nodes or edges:
+'changed_handler' is called when the user (de)selected nodes or edges:
 ```
-def graph_selection(_, val):
-    _.value = val
+def changed_handler(graph, val):
+    graph.value = val
     if 'nodes' in val:        
         return Info(f'Nodes {val["nodes"]}') 
     if 'edges' in val:
         return Info(f"Edges {val['edges']}") 
 ```
-With pressed 'Shift' multi select works for nodes and edges.
+With pressed 'Shift' multi (de)select works for nodes and edges.
 
 id nodes and edges are optinal, if node ids are ommited then edge 'source' and 'target' have to point node index in nodes array.
+Graph can handle invalid edges and null nodes in the nodes array.   
 
 ### Dialog ###
 ```
-Dialog(text, dialog_callback, commands = ['Ok', 'Cancel'], *content)
+Dialog(question, dialog_callback, commands = ['Ok', 'Cancel'], *content)
 ```
 where buttons is a list of the dialog button names,
 Dialog callback has the signature as other with a pushed button name value
 ```
-def dialog_callback(current_dialog, pushed_button_name):
-    if pushed_button_name == 'Yes':
+def dialog_callback(current_dialog, command_button_name):
+    if command_button_name == 'Yes':
         do_this()
     elif ..
 ```
-content can be filled with Gui elements for additional dialog functionality.
+content can be filled with Gui elements for additional dialog functionality like a Block.
 
 
 ### Popup windows ###
@@ -398,9 +423,9 @@ Progree window is automatically closed when the handler is finished.
 Unisi automatically creates and serves an environment for every user.
 The management class is User contains all required methods for processing and handling the user activity. A programmer can redefine methods in the inherited class, point it as system user class and that is all. Such methods suit for history navigation, undo/redo and initial operations. The screen folder contains screens which are recreated for every user. The same about blocks. The code and modules outside that folders are common for all users as usual. By default Unisi uses the system User class and you do not need to point it. 
 ```
-class Hello_user(unisi.User):
+class Hello_user(unisi.User, session, share = None):
     def __init__(self):
-        super().__init__()
+        super().__init__(session, share)
         print('New Hello user connected and created!')
 
 unisi.start('Hello app', user_type = Hello_user)
@@ -457,10 +482,19 @@ if proxy.set_screen("Image analysis"):
 proxy.close()
 ```
 
+### REST ##
 
+The REST service facilitates the REST interface through the following approach: a programmer is required to define aiohttp routes, which consist of routes and handlers, such as web.get('/', hello), and then pass it to the Unisi start function. 
 
-### 'Become a serious web programmer in 1 hour.' is a crash course how to use UNISI ###
-   https://www.unisi.tech/learn
+```
+from aiohttp import web
+import unisi
+async def handle_get(request):
+print(request.query_string)
+http_handlers = [web.get('/get', handle_get)]
+unisi.start(http_handlers = http_handlers)
+```
+#### REST is redundant because UNISI automatically provides the Unified Remote API without programming. Can use Proxy for accessing and querying. ####
 
 Examples are in tests folder.
 

{unisi-0.1.9.dist-info → unisi-0.1.10.dist-info}/RECORD

@@ -1,8 +1,8 @@
-unisi-0.1.9.dist-info/METADATA,sha256=4JSNUcDiQsUS00Fzwb1rN2BFURciTyOX44HfaYkn5Nc,19754
-unisi-0.1.9.dist-info/WHEEL,sha256=N2J68yzZqJh3mI_Wg92rwhw0rtJDFpZj9bwQIMJgaVg,90
-unisi-0.1.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+unisi-0.1.10.dist-info/METADATA,sha256=VJYe06r0OBYZAx_YSCYGL5RiOZECwl0TcUn0Yw2iwTY,21428
+unisi-0.1.10.dist-info/WHEEL,sha256=N2J68yzZqJh3mI_Wg92rwhw0rtJDFpZj9bwQIMJgaVg,90
+unisi-0.1.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 unisi/__init__.py,sha256=bQ7yTDcgybkbIGTjxkajTbBJXtgyryrCvt3nXg8QxlQ,175
-unisi/autotest.py,sha256=mkvfUuxO7co9QcninjBSS9u-zJSva9H_51k3m6sd3rw,9485
+unisi/autotest.py,sha256=sB4WCyxp9TB5r0OkxeO8_jlj3END4xKOr12l2gen6Yg,9469
 unisi/common.py,sha256=jsZpOkZIQdfPZjrTIoO1OLiZfQ_spEpMCX3td269RR0,635
 unisi/containers.py,sha256=Me28aZkhchWJA5OExtXoFzl2u5bc6p0m2Cww7CfKIbA,4200
 unisi/guielements.py,sha256=svPMIEMbhW5uH4jz5rsjTeVVFl_P7VrMniTFFQvpmzs,5998
@@ -11,11 +11,11 @@ unisi/jsoncomparison/compare.py,sha256=qPDaxd9n0GgiNd2SgrcRWvRDoXGg7NStViP9PHk2t
 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/proxy.py,sha256=34Ql_UbqvBowc8V7qjDUSK3KhyxpcSyzjJV1iUOPo4A,7614
+unisi/proxy.py,sha256=meZ4-26KXefuaZ04Gfrexij7rreBPKLPJSwPCIqftx0,7660
 unisi/reloader.py,sha256=B0f9GU452epFvdih8sH7_NiIJrXnC5i27uw2imGQxMg,6585
-unisi/server.py,sha256=5oax_OGWGPNm1smQM_8EpCb1jKia2s7IBnIfjIr1Z2w,4583
+unisi/server.py,sha256=v17oT4smLi4XZpsf7lVazisYOH3Ak3GPBFmsSrGt8-8,5136
 unisi/tables.py,sha256=v7Fio5iIN7u1t7cE4Yvl4ewn7jTmmNPyWigoKW1Mj8U,4239
-unisi/users.py,sha256=JD4AD0WyuJQK31juWURqHwbeHF-016nifGQBZutHSPI,9818
+unisi/users.py,sha256=g8YMOvDmibgu-kxvl884_WdlMAcrN2UNQseSqHGFBzc,10636
 unisi/utils.py,sha256=6iDXECQE_44v8m6fvte_PXM0Ku6ZV-8LkAqMcNSMYdk,2975
 unisi/web/css/353.64dbc68c.css,sha256=ckeNz4l2QkIp60LdV_-cEXf9orp0ZVklEbrQfjkAG5M,2691
 unisi/web/css/app.31d6cfe0.css,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -39,4 +39,4 @@ unisi/web/js/353.ddd028b2.js,sha256=DQGZ3nBM5feVYkLf3293CmnNfIcKs8WKq8MySyO9HQA,
 unisi/web/js/430.591e9a73.js,sha256=7S1CJTwGdE2EKXzeFRcaYuTrn0QteoVI03Hykz8qh3s,6560
 unisi/web/js/app.bf75d7b6.js,sha256=2tat-f-LfOgU17bsIx4OrmVZbVdQNRhlh-cYWjPEohk,5923
 unisi/web/js/vendor.d6797c01.js,sha256=2aKM3Lfxc0pHSirrcUReL1LcvDYWnfeBj2c67XsSELk,1279477
-unisi-0.1.9.dist-info/RECORD,,
+unisi-0.1.10.dist-info/RECORD,,