unisi 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

unisi/autotest.py

@@ -4,7 +4,7 @@ from .guielements import *
 from .containers import Block, Dialog
 from .users import User
 from .common import *
-from jsoncomparison import Compare, NO_DIFF
+from .jsoncomparison import Compare, NO_DIFF
 
 #setting config variables
 testdir = 'autotest'
@@ -34,7 +34,7 @@ logfile = config.logfile
 handlers = [logging.FileHandler(logfile), logging.StreamHandler()] if logfile else []
 logging.basicConfig(level = logging.WARNING, format = format, handlers = handlers)
 
-comparator = Compare().check
+comparator = Compare(rules = {'toolbar': '*'}).check
 
 def jsonString(obj):
     pretty = config.pretty_print
@@ -44,15 +44,13 @@ class Recorder:
     def __init__(self):
         self.start(None)
         
-    def accept(self, msg, response):        
-        if self.ignored_1message:            
+    def accept(self, msg, response):  
+        if not self.ignored_1message: 
+           self.ignored_1message = True   
+        else:           
             self.record_buffer.append(f"{jsonString(msg)},\
-                \n{'null' if response is None else jsonString(response)}\n")
-        else: #start for setting screen
-            self.record_buffer.append(jsonString(ArgObject(block = 'root', 
-                element = None, value = User.last_user.screen_module.name)))
-            self.ignored_1message = True    
-
+              \n{'null' if response is None else jsonString(response)}\n")
+        
     def stop_recording(self, _, x):    
         button.spinner = None
         button.changed = button_clicked
@@ -69,44 +67,69 @@ class Recorder:
             Warning('Nothing to save!',button)
 
     def start(self,fname):
-        self.record_file = fname
-        self.ignored_1message = False
+        self.record_file = fname        
         self.record_buffer = []
+        if fname:
+            self.ignored_1message = True
+            module = User.last_user.screen_module
+            self.accept(ArgObject(block = 'root', element = None,
+                event = 'changed', value = module.name), module.screen)
+            self.ignored_1message = False
 
 recorder = Recorder()
 
-def obj2pyjson(obj):
+def obj2json(obj):
     return json.loads(jsonpickle.encode(obj,unpicklable=False))
 
 def test(filename, user):
     filepath = f'{testdir}{divpath}{filename}'
     file = open(filepath, "r") 
-    data = json.loads(file.read())
+    data = json.loads(file.read())    
     error = False
-    for message in data:
-        if message is not None and message.get('block'):
-            result = user.result4message(ReceivedMessage(message))
-            response = user.prepare_result(result)
-            user_message = message
-        else:
-            diff = comparator(message, obj2pyjson(response))
-            if diff != NO_DIFF:
-                print(f"\nTest {filename} is failed on message {user_message}:")
-                err = diff.get('_message')
-                if err:
-                    print(f"  {err}")
-                else:
-                    for value in diff.values():
-                        err = value['_message']                        
-                        print(f"  {err}")
-                error = True
+    for i in range(0, len(data), 2):
+        message = data[i]
+        expected = data[i + 1]
+            
+        result = user.result4message(ReceivedMessage(message))
+        responce = user.prepare_result(result)
+        jresponce = obj2json(responce)
+        
+        diff = comparator(expected, jresponce)
+        if diff != NO_DIFF:
+            print(f"\nTest {filename} is failed on message {message}:")
+            err = diff.get('_message')
+            if err:
+                print(f"  {err}")
+            else:
+                for key, obj in diff.items():                                             
+                    if key != '#name':
+                        while True:
+                                err = obj.get('_message')
+                                if err:
+                                    print(f"  {err} \n")
+                                    break
+                                else: 
+                                    content = obj.get('_content')
+                                    if content and len(obj) == 1:
+                                        obj = content
+                                    else:
+                                        for key, subobj in obj.items():
+                                            if key != '_content': 
+                                                if isinstance(key, str):  
+                                                    name = obj.get('#name', '')                                                                             
+                                                    if name:
+                                                        key = f'  {name}: {key}'
+                                                    print(f"  {key}")
+                                                obj = subobj
+                                                break                                                                
+            error = True
     return not error
 
 test_name = Edit('Name test file', '', focus = True)
 rewrite = Switch('Overwrite existing', False, type = 'check')
 
 def button_clicked(_,__):
-    test_name.value = ''
+    test_name.value = User.last_user.screen.name
     test_name.complete = smart_complete(os.listdir(testdir))
     return Dialog('Create autotest..', ask_create_test, test_name, rewrite)
 
@@ -152,19 +175,19 @@ def check_block(self):
             child_names.add(child.name)                
     return errors
 
-def check_screen(module):
-    self = module.screen
+def check_module(module):
+    screen = module.screen
     errors =  []        
     block_names = set()        
-    if not hasattr(self, 'name') or not self.name:            
+    if not hasattr(screen, 'name') or not screen.name:            
         errors.append(f"Screen file {module.__file__} does not contain name!")
-        self.name = 'Unknown'
-    elif not isinstance(self.name, str):
-        errors.append(f"The name in screen file {module.__file__} {self.name} is not a string!")
-    if not isinstance(self.blocks, list):
+        screen.name = 'Unknown'
+    elif not isinstance(screen.name, str):
+        errors.append(f"The name in screen file {module.__file__} {screen.name} is not a string!")
+    if not isinstance(screen.blocks, list):
         errors.append(f"Screen file {module.__file__} does not contain 'blocks' list!")
     else:
-        for bl in flatten(self.blocks):            
+        for bl in flatten(screen.blocks):            
             if not isinstance(bl, Block):
                 errors.append(f'The screen contains invalid element {bl} instead of Block object!')                                                    
             elif bl.name in block_names:
@@ -173,7 +196,7 @@ def check_screen(module):
                 block_names.add(bl.name)
             errors += check_block(bl)
     if errors:
-        errors.insert(0, f"\nErrors in screen {self.name}, file name {module.__file__}:")
+        errors.insert(0, f"\nErrors in screen {screen.name}, file name {module.__file__}:")
     return errors
     
 def run_tests():
@@ -184,9 +207,9 @@ def run_tests():
     user.session = 'autotest'
     errors = []
     for module in user.screens:
-        errors += check_screen(module)
+        errors += check_module(module)
     if errors:
-        errors.insert(0, f'\n!!----Unisi detected errors in screens:')
+        errors.insert(0, f'\n!!----Detected errors in screens:')
         print('\n'.join(errors), '\n')
     elif user.screens:
         print(f'\n----The screen definitions are correct.-----\n')

unisi/jsoncomparison/__init__.py

@@ -0,0 +1,21 @@
+from .compare import NO_DIFF, Compare
+from .errors import (
+    KeyNotExist,
+    LengthsNotEqual,
+    TypesNotEqual,
+    UnexpectedKey,
+    ValueNotFound,
+    ValuesNotEqual,
+)
+
+__all__ = (
+    "Compare",
+    "NO_DIFF",
+
+    "ValuesNotEqual",
+    "TypesNotEqual",
+    "KeyNotExist",
+    "ValueNotFound",
+    "LengthsNotEqual",
+    "UnexpectedKey",
+)

unisi/jsoncomparison/compare.py

@@ -0,0 +1,233 @@
+import copy
+import json
+from typing import Optional
+
+from .config import Config
+from .errors import (
+    KeyNotExist,
+    LengthsNotEqual,
+    TypesNotEqual,
+    UnexpectedKey,
+    ValueNotFound,
+    ValuesNotEqual,
+)
+from .ignore import Ignore
+
+NO_DIFF: dict = {}
+NO_RULES: dict = {}
+
+DEFAULT_CONFIG = {
+    'output': {
+        'console': False,
+        'file': {
+            'allow_nan': True,
+            'ensure_ascii': True,
+            'indent': 4,
+            'name': None,
+            'skipkeys': True,
+        },
+    },
+    'types': {
+        'float': {
+            'allow_round': 2,
+        },
+        'list': {
+            'check_length': True,
+        },
+    },
+}
+
+
+class Compare:
+
+    __slots__ = ("_config", "_rules")
+
+    def __init__(
+        self,
+        config: Optional[dict] = None,
+        rules: Optional[dict] = None,
+    ):
+        if not config:
+            config = DEFAULT_CONFIG
+        if not rules:
+            rules = NO_RULES
+
+        self._config = Config(config)
+        self._rules = rules
+
+    def check(self, expected, actual):
+        e = self.prepare(expected)
+        a = self.prepare(actual)
+        diff = self._diff(e, a)
+        self.report(diff)
+        return diff
+
+    def _diff(self, e, a):
+        t = type(e)
+        if not isinstance(a, t):
+            return TypesNotEqual(e, a).explain()
+        if t is int:
+            return self._int_diff(e, a)
+        if t is str:
+            return self._str_diff(e, a)
+        if t is bool:
+            return self._bool_diff(e, a)
+        if t is float:
+            return self._float_diff(e, a)
+        if t is dict:
+            return self._dict_diff(e, a)
+        if t is list:
+            return self._list_diff(e, a)
+        return NO_DIFF
+
+    @classmethod
+    def _int_diff(cls, e, a):
+        if a == e:
+            return NO_DIFF
+        return ValuesNotEqual(e, a).explain()
+
+    @classmethod
+    def _bool_diff(cls, e, a):
+        if a is e:
+            return NO_DIFF
+        return ValuesNotEqual(e, a).explain()
+
+    @classmethod
+    def _str_diff(cls, e, a):
+        if a == e:
+            return NO_DIFF
+        return ValuesNotEqual(e, a).explain()
+
+    def _float_diff(self, e, a):
+        if a == e:
+            return NO_DIFF
+        if self._can_rounded_float():
+            p = self._float_precision()
+            e, a = round(e, p), round(a, p)
+            if a == e:
+                return NO_DIFF
+        return ValuesNotEqual(e, a).explain()
+
+    def _can_rounded_float(self):
+        p = self._float_precision()
+        return type(p) is int
+
+    def _float_precision(self):
+        path = 'types.float.allow_round'
+        return self._config.get(path)
+
+    def _dict_diff(self, e, a):
+        if not isinstance(a, dict):
+            d = {'type' : {'_message': 'Incompatible types'}}
+        else:
+            d = {}        
+            for k in e:
+                if k not in a:
+                    d[k] = KeyNotExist(k, None).explain()
+                else:
+                    d[k] = self._diff(e[k], a[k])
+            
+            for k in a:
+                if k not in e:
+                    d[k] = UnexpectedKey(None, k).explain()
+                else:
+                    d[k] = self._diff(e[k], a[k])
+
+        diffs = self._without_empties(d)
+        if diffs:
+            name = e.get('name')
+            if name:
+                diffs['#name'] = name
+        return diffs
+
+    def _list_diff(self, e, a):
+        if not isinstance(a, list):
+            d = {'type' : {'_message': 'Incompatible types'}}
+        else:
+            d = {}
+            if self._need_compare_length():
+                d['_length'] = self._list_len_diff(e, a)
+            d['_content'] = self._list_content_diff(e, a)
+            return self._without_empties(d)
+
+    def _need_compare_length(self):
+        path = 'types.list.check_length'
+        return self._config.get(path) is True
+
+    def _list_content_diff(self, e, a):
+        d = {}
+        len_a = len(a)
+        for i, v in enumerate(e):            
+            if i < len_a:
+                t = type(v)
+                if t in (int, str, bool, float):
+                    if v != a[i]:
+                        d[i] = ValuesNotEqual(v, a[i]).explain()
+                elif t is dict:
+                    d[i] = self._dict_diff(v, a[i])
+                elif t is list:
+                    d[i] = self._list_diff(v, a[i])
+        return self._without_empties(d)
+
+    @classmethod
+    def _max_diff(cls, e, lst, method):
+        t = type(e)
+        d = method(e, t())
+        for i, v in enumerate(lst):
+            if type(v) is t:
+                dd = method(e, v)
+                if len(dd) <= len(d):
+                    d = dd
+        return d
+
+    @classmethod
+    def _min_diff(cls, e, lst, method):
+        t = type(e)
+        d = method(e, t())
+        for i, v in enumerate(lst):
+            if type(v) is t:
+                dd = method(e, v)
+                if len(dd) <= len(d):
+                    d = dd
+                    break
+        return d
+
+    @classmethod
+    def _list_len_diff(cls, e, a):
+        e, a = len(e), len(a)
+        if e == a:
+            return NO_DIFF
+        return LengthsNotEqual(e, a).explain()
+
+    @classmethod
+    def _without_empties(cls, d):
+        return {k: d[k] for k in d if d[k] != NO_DIFF}
+
+    def report(self, diff):
+        if self._need_write_to_console():
+            self._write_to_console(diff)
+        if self._need_write_to_file():
+            self._write_to_file(diff)
+
+    @classmethod
+    def _write_to_console(cls, d):
+        msg = json.dumps(d, indent=4)
+        print(msg)
+
+    def _write_to_file(self, d):
+        config = self._config.get('output.file')
+        with open(config.pop('name'), 'w') as fp:
+            json.dump(d, fp, **config)
+
+    def _need_write_to_console(self):
+        path = 'output.console'
+        return self._config.get(path) is True
+
+    def _need_write_to_file(self):
+        path = 'output.file.name'
+        file_name = self._config.get(path)
+        return type(file_name) is str
+
+    def prepare(self, x):
+        x = copy.deepcopy(x)
+        return Ignore.transform(x, self._rules)

unisi/jsoncomparison/config.py

@@ -0,0 +1,15 @@
+class Config:
+    def __init__(self, config: dict):
+        self.config = config
+
+    def get(self, path):
+        value = self.config
+        for key in path.split('.'):
+            try:
+                value = value.get(key, {})
+            except AttributeError:
+                return False
+        return value
+
+    def merge(self, config):
+        self.config.update(config)

unisi/jsoncomparison/errors.py

@@ -0,0 +1,53 @@
+from abc import ABC
+
+
+class Error(ABC):
+    expected = None
+    received = None
+
+    template = 'Expected: <{e}>, received: <{r}>'
+
+    def __init__(self, expected, received):
+        self.expected = expected
+        self.received = received
+
+    @property
+    def message(self):
+        msg = self.template.format(e=self.expected, r=self.received)
+        return msg
+
+    def explain(self):
+        return {
+            '_message': self.message,
+            '_expected': self.expected,
+            '_received': self.received,
+        }
+
+
+class TypesNotEqual(Error):
+    template = 'Types not equal. Expected: <{e}>, received: <{r}>'
+
+    def __init__(self, e, a):
+        e = type(e).__name__
+        a = type(a).__name__
+        super().__init__(e, a)
+
+
+class ValuesNotEqual(Error):
+    template = 'Values not equal. Expected: <{e}>, received: <{r}>'
+
+
+class KeyNotExist(Error):
+    template = 'Key does not exist. Expected: <{e}>'
+
+
+class LengthsNotEqual(Error):
+    template = 'Lengths not equal. Expected <{e}>, received: <{r}>'
+
+
+class ValueNotFound(Error):
+    template = 'Value not found. Expected <{e}>'
+
+
+class UnexpectedKey(Error):
+    template = 'Unexpected key. Received: <{r}>'

unisi/jsoncomparison/ignore.py

@@ -0,0 +1,91 @@
+import re
+from abc import ABC
+
+
+class Ignore(ABC):
+
+    @classmethod
+    def transform(cls, obj, rules):
+        t = type(rules)
+        if obj:
+            if t is dict:
+                return cls._apply_dictable_rule(obj, rules)
+            if t is list:
+                return cls._apply_listable_rule(obj, rules)
+        return obj
+
+    @classmethod
+    def _apply_dictable_rule(cls, obj, rules):
+        for key in rules:
+            rule = rules[key]
+            if cls._is_special_key(key):
+                obj = cls._apply_special_rule(key, obj, rule)
+            elif cls._is_regex_rule(rule):
+                obj = cls._apply_regex_rule(key, obj, rule)
+            elif type(rule) is str:
+                obj = cls._apply_stringable_rule(key, obj, rule)
+            elif key in obj:
+                obj[key] = cls.transform(obj[key], rule)
+        return obj
+
+    @classmethod
+    def _apply_listable_rule(cls, obj, rules):
+        for key in rules:
+            if type(key) is dict:
+                for index, y in enumerate(obj):
+                    obj[index] = cls.transform(obj[index], key)
+            elif key in obj:
+                del obj[key]
+        return obj
+
+    @classmethod
+    def _apply_stringable_rule(cls, key, obj, rule):
+        if rule == '*':
+            if key in obj:
+                del obj[key]
+        return obj
+
+    @classmethod
+    def _is_regex_rule(cls, rule):
+        return type(rule) is dict and '_re' in rule
+
+    @classmethod
+    def _apply_regex_rule(cls, key, obj, rule):
+        regex = rule['_re']
+        if key in obj and re.match(regex, obj[key]):
+            del obj[key]
+        return obj
+
+    @classmethod
+    def _is_special_key(cls, key):
+        return key.startswith('_')
+
+    @classmethod
+    def _apply_special_rule(cls, key, obj, rule):
+        if key == '_values':
+            return cls._ignore_values(obj, rule)
+        if key == '_list':
+            return cls._ignore_list_items(obj, rule)
+        if key == '_range':
+            return cls._ignore_range(obj, rule)
+        return obj
+
+    @classmethod
+    def _ignore_list_items(cls, obj, rule):
+        return [cls.transform(x, rule) for x in obj]
+
+    @classmethod
+    def _ignore_values(cls, obj, black_list):
+        t = type(obj)
+        if t is list:
+            return [x for x in obj if x not in black_list]
+        if t is dict:
+            return {k: obj[k] for k in obj if k not in black_list}
+        return obj
+
+    @classmethod
+    def _ignore_range(cls, obj, rule):
+        t = type(obj)
+        if t is int or t is float:
+            return rule[0] <= obj and obj <= rule[1]
+        return obj

unisi/proxy.py

@@ -40,7 +40,7 @@ class Proxy:
 
     def close(self):
         self.conn.close()
-
+    
     @property
     def screen_menu(self):
         return [name_icon[0] for name_icon in self.screen['menu']] if self.screen else []
@@ -66,7 +66,7 @@ class Proxy:
                 if el == element:
                     return block
     
-    def message(self, element, value, event = 'changed'):
+    def message(self, element, value = None, event = 'changed'):
         if event != 'changed' and event not in element:
             return None
         return ArgObject(block = self.block_of(element), element = element['name'], 

unisi/reloader.py

@@ -17,7 +17,7 @@ if config.hot_reload:
     from watchdog.events import PatternMatchingEventHandler
     from .users import User
     from .utils import divpath, Redesign, app_dir
-    from .autotest import check_screen
+    from .autotest import check_module
     import re, collections
 
     #for removing message duplicates        
@@ -48,7 +48,7 @@ if config.hot_reload:
 
             try:
                 module = user.load_screen(sname)
-                errors = check_screen(module)                                
+                errors = check_module(module)                                
                 if errors:
                     print('\n'.join(errors))
                     busy = False

unisi/users.py

@@ -175,7 +175,7 @@ class User:
 
     def process(self, message):
         self.last_message = message     
-        screen_change_message = message.screen and self.screen.name != message.screen   
+        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:
                 if s.name == message.value:

{unisi-0.1.1.dist-info → unisi-0.1.3.dist-info}/METADATA

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: unisi
-Version: 0.1.1
+Version: 0.1.3
 Summary: UNified System Interface, GUI and proxy
 Author-Email: UNISI Tech <g.dernovoy@gmail.com>
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/unisi-tech/unisi
 Requires-Python: >=3.8
 Requires-Dist: aiohttp
-Requires-Dist: jsoncomparison
 Requires-Dist: jsonpickle
 Requires-Dist: pandas
 Requires-Dist: requests
@@ -29,8 +28,9 @@ UNISI technology provides a unified system interface and advanced program functi
  - Hot reloading and updating
  - Integral autotesting
  - Protocol schema auto validation
+ - Shared sessions
  - Voice interaction (not released yet)
- - Developing data pipelines (not released yet)
+ - Remote GUI interaction and pipelining (not released yet)
 
 ### Installing ###
 ```
@@ -87,7 +87,7 @@ 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/be828e3a-00f8-41ad-9e97-82c01fd566e6)
+![image](https://github.com/unisi-tech/unisi/assets/1247062/dafebd1f-ae48-4790-9282-dea83d986749)
 
 ### Handling events ###
 All handlers are functions which have a signature
@@ -112,7 +112,7 @@ clean_button = Button('Clean the table’, clean_table)
 | Gui object |  Object to update |
 | Gui object array or tuple |  Objects to update |
 | None | Nothing to update, Ok |
-| Error(...), Warning(...), Info(...) | Show to user info about a problem. |
+| Error(...), Warning(...), Info(...) | Show to user info about a state. |
 | UpdateScreen, True | Redraw whole screen |
 | Dialog(..) | Open a dialog with parameters |
 | user.set_screen(screen_name) | switch to another screen |
@@ -125,12 +125,11 @@ If a Gui object doesn't have 'changed' handler the object accepts incoming value
 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(_, value):
-   if value < 0.5 and value > 1.0:
-       #or Error(message, _) if we want to return the previous visible value to the field, return gui object _ also.
-       return Error(f‘The value of {_.name} has to be > 0.5 and < 1.0!', _) 
+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) 
     #accept value othewise
-    _.value = value
+    guirange.value = value
 
 edit = Edit('Range of involving', 0.6, changed_range, type = 'number')
 ```

{unisi-0.1.1.dist-info → unisi-0.1.3.dist-info}/RECORD

@@ -1,16 +1,21 @@
-unisi-0.1.1.dist-info/METADATA,sha256=jF4HA-7YYP-mScrb5gIIWNQlB_ecsGzDt2-JglzUseQ,18622
-unisi-0.1.1.dist-info/WHEEL,sha256=N2J68yzZqJh3mI_Wg92rwhw0rtJDFpZj9bwQIMJgaVg,90
-unisi-0.1.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+unisi-0.1.3.dist-info/METADATA,sha256=pYm__IDa4WqrhosAznrglBGaXw1Ryd-zIF821ajKGrc,18539
+unisi-0.1.3.dist-info/WHEEL,sha256=N2J68yzZqJh3mI_Wg92rwhw0rtJDFpZj9bwQIMJgaVg,90
+unisi-0.1.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 unisi/__init__.py,sha256=bQ7yTDcgybkbIGTjxkajTbBJXtgyryrCvt3nXg8QxlQ,175
-unisi/autotest.py,sha256=mqf6FPPewadwQenG_rgZhhLZEhvZ0H_kLGH1570aLho,8053
+unisi/autotest.py,sha256=K_ev2UcUdMwt6YwK-ueOPavX6ikHylldIF81v05e95o,9397
 unisi/common.py,sha256=oQJdUHVIf3QEMlnRSY_FW-ce4oDb7xcmzOhHByKGC7w,753
 unisi/containers.py,sha256=_oB1KknoHAslpmVHY_dpX4uOcKtP5Pelqdv9fMjotHo,3403
 unisi/guielements.py,sha256=SVfAU9zrGMdzuU3Ip0dAnaPyJSmwoOaozn3LLNW0tkQ,5384
-unisi/proxy.py,sha256=YENWammF8xSAgHKUSQJqLVFXhnwdZOGA_sAPSqqEfa8,5728
-unisi/reloader.py,sha256=X4bxZn0P6Ey7mj4SAs8rz4RjEtpXd8vny1aGbyYnnik,6424
+unisi/jsoncomparison/__init__.py,sha256=lsWkYEuL6v3Qol-lwSUvB6y63tm6AKcCMUd4DZDx3Cg,350
+unisi/jsoncomparison/compare.py,sha256=XlJqeNaj_zmiD-x_Rz_9R2RYkDd7JCOzojoFtIsrBVU,6158
+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=bbuuOitToR-hmy5wQ6sqnJChze0ZuqKr1eHWyhGWXIY,5739
+unisi/reloader.py,sha256=MkmN6mDclrdzuO5I4Hu_GGjOyl-icnJ-IdwyNW8xEYs,6424
 unisi/server.py,sha256=SKN38DjuxZ0U_FjBJDuwnpDP2YfZorpIJrjrADhqf5w,4521
 unisi/tables.py,sha256=v7Fio5iIN7u1t7cE4Yvl4ewn7jTmmNPyWigoKW1Mj8U,4239
-unisi/users.py,sha256=OFfNrPfYPrBeyziWOO0gB6UlX8vG2VpglrMdY1-_Mi4,9805
+unisi/users.py,sha256=B3Ouj-Ygx9BYU64JtE_HM4yApIZ7ikVeH2v86Lr1rSA,9819
 unisi/utils.py,sha256=KnyjouXGnN8ubuwogMa1tu2HJSkmDqhuFf7RpU3n9bY,2971
 unisi/web/css/815.30ec41a2.css,sha256=b8La7chOFF3VPd-kqAbwP-Cx8jMzkgZCbYsMXR2mhKI,2723
 unisi/web/css/app.31d6cfe0.css,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -34,4 +39,4 @@ unisi/web/js/430.591e9a73.js,sha256=7S1CJTwGdE2EKXzeFRcaYuTrn0QteoVI03Hykz8qh3s,
 unisi/web/js/815.e46226ff.js,sha256=xpfhA0GvPjvracUep66rqrKLCho-Muiw1N8nr9QzDNc,55923
 unisi/web/js/app.29d640d6.js,sha256=v_u_Q9vvmrgTj7-4CdpB8yQOl19a-FC6YVCXnSyTfec,5923
 unisi/web/js/vendor.d6797c01.js,sha256=2aKM3Lfxc0pHSirrcUReL1LcvDYWnfeBj2c67XsSELk,1279477
-unisi-0.1.1.dist-info/RECORD,,
+unisi-0.1.3.dist-info/RECORD,,