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

unisi/common.py

@@ -1,4 +1,7 @@
-import jsonpickle
+import jsonpickle, inspect
+
+UpdateScreen = True
+Redesign = 2
 
 def flatten(*arr):
     for a in arr:
@@ -6,22 +9,135 @@ def flatten(*arr):
             yield from flatten(*a)
         else:
             yield a
-            
+
+def compose_returns(*arr):
+    objs = set()
+    update_screen = False
+    for obj in flatten(*arr):
+        if obj is Redesign:
+            return obj
+        elif obj is True:
+            update_screen = True
+        elif obj is not None:
+            objs.add(obj)            
+    if update_screen:
+        return True
+    if objs:
+        return list(objs)
+    
+def equal_dicts(dict1, dict2):
+    return dict1.keys() == dict2.keys() and all(dict1[key] == dict2[key] for key in dict1)
+
 class ArgObject:
     def __init__(self, **kwargs):
         self.__dict__.update(kwargs)
+    def __getattr__(self, _):
+        """return None for unknown props"""
+        return None
 
-class ReceivedMessage:
-    def __init__(self, data):
-        self.__dict__.update(data)
-        self.screen = data.get('screen')        
-        self.value = data.get('value')        
+class ReceivedMessage(ArgObject):
+    def __init__(self, kwargs):
+        super().__init__(**kwargs)
     def __str__(self):
         return f'{self.block}/{self.element}->{self.event}({self.value})'
 
 def toJson(obj):
     return jsonpickle.encode(obj,unpicklable = False)
 
+def set_defaults(self, param_defaults : dict):
+    for param, value in param_defaults.items():
+        if not hasattr(self, param):
+            setattr(self, param, value)
+
+def pretty4(name):
+    pretty_name = name.replace('_',' ')
+    return pretty_name[0].upper() + pretty_name[1:]
+
+def is_callable(obj):
+    return inspect.isfunction(obj) or inspect.ismethod(obj) or inspect.iscoroutine(obj) or callable(obj)        
+
+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 get_default_args(func):
+    """  
+    class F:
+        def example_function(a, b, c=10, d='hello'):
+            pass
+    f = F()
+    default_args = get_default_args(f.example_function)
+    print(default_args)  
+    """
+    # Get the signature of the function
+    sig = inspect.signature(func)
+    # Dictionary to store arguments with their default values
+    defaults = {}
+    for name, param in sig.parameters.items():
+        if param.default != inspect.Parameter.empty:
+            defaults[name] = param.default
+    return defaults
+
+references = ArgObject(context_user = None)
+
+class Message:
+    def __init__(self, *gui_objects, user = None, type = 'update'):        
+        self.type = type
+        if gui_objects:
+            self.updates = [{'data': gui} for gui in gui_objects]
+        if user:
+            self.fill_paths4(user)
+
+    def fill_paths4(self, user):
+        if hasattr(self, 'updates'):
+            invalid = []
+            for update in self.updates:
+                data = update["data"]
+                path = user.find_path(data)
+                if path:
+                    update['path'] = path
+                else:
+                    invalid.append(update)                    
+                    user.log(f'Invalid element update {data.name}, type {data.type}.\n\
+                    Such element not on the screen!')
+            for inv in invalid:
+                self.updates.remove(inv)
+
+    def contains(self, guiobj):
+        if hasattr(self, 'updates'):
+            for update in self.updates:
+                if guiobj is update['data']:
+                    return True
+
+def TypeMessage(type, value, *data, user = None):
+    message = Message(*data, user=user, type = type)    
+    message.value = value    
+    return message    
+
+def Warning(text, *data):
+    return TypeMessage('warning', text, *data)
+
+def Error(text, *data):
+    return TypeMessage('error', text, *data)
+    
+def Info(text, *data):
+    return TypeMessage('info', text, *data)
+
+def Answer(type, message, result):
+    ms = TypeMessage(type, result)
+    ms.message = message
+    return ms
+
+
 
 
 

unisi/containers.py

@@ -1,4 +1,5 @@
-from .guielements import Gui, Range, Edit, Switch, Select, Tree
+from .guielements import *
+from .common import pretty4
 from numbers import Number
 
 
@@ -58,8 +59,7 @@ class ParamBlock(Block):
         cnt = 0        
 
         for param, val in params.items():                    
-            pretty_name = param.replace('_',' ')
-            pretty_name = pretty_name[0].upper() + pretty_name[1:]
+            pretty_name = pretty4(param)            
             t = type(val)
             if t == str or t == int or t == float:
                 el = Edit(pretty_name, val)

unisi/dbelements.py

@@ -0,0 +1,155 @@
+class Dblist:
+    def __init__(self, dbtable, init_list = None, cache = None):                
+        self.cache = cache
+        self.limit = dbtable.limit
+        if cache is not None:            
+            init_list = cache[:self.limit]      
+        elif init_list is None:
+            raise AttributeError('init_list or cache has to be assigned!')
+                              
+        self.delta_list = {0 : init_list}                
+        self.dbtable = dbtable                
+        self.update = dict(type ='init', length = len(self), 
+                limit = self.limit, data = init_list) 
+
+    def get_delta_0(self):
+        return self.delta_list[0]
+
+    def __getattribute__(self, name):
+        if name == '__dict__':
+            return object.__getattribute__(self, 'update')
+        return object.__getattribute__(self, name)
+    
+    def __getattr__(self, name):
+        return self.dbtable.limit if name == 'limit' else None
+        
+    """ The methods causes invalid serialization!
+    def __iter__(self):
+        "Override the default iterator to provide custom behavior."
+        self._index = 0
+        return self
+
+    def __next__(self):        
+        if self._index < len(self):
+            value = self[self._index]
+            self._index += 1
+            return value
+        else:
+            raise StopIteration
+    """
+    
+    def __str__(self):
+        return f'\ndeltas: {self.delta_list}\nupdate: {self.update}'        
+        
+    def get_delta_chunk(self, index):
+        if index >= len(self):
+            return -1, None
+        delta_list = index // self.limit * self.limit
+        
+        if self.cache is not None:
+            return delta_list, self.cache[delta_list:delta_list + self.limit]
+        
+        lst = self.delta_list.get(delta_list)
+        if lst:
+            return delta_list, lst
+        lst = self.dbtable.read_rows(skip = delta_list)
+        self.delta_list[delta_list] = lst        
+        return delta_list, lst
+
+    def __getitem__(self, index):        
+        if self.cache is not None:
+            return self.cache[index]
+        delta_list, chunk = self.get_delta_chunk(index)
+        if chunk:
+            return chunk[index - delta_list]        
+
+    def __setitem__(self, index, value):
+        if self.cache is not None:
+            self.cache[index] = value
+        else:
+            delta_list, chunk = self.get_delta_chunk(index)
+            if chunk:
+                chunk[index - delta_list] = value
+            self.update = dict(type = 'update', index = index, data = value)
+            self.dbtable.assign_row(value)
+
+    def clean_cache_from(self, delta_list):
+        """clear dirty delta_list cache"""
+        self.delta_list = {k: v for k, v in self.delta_list.items() if k < delta_list}                
+        
+    def __delitem__(self, index):
+        delta_list, chunk = self.get_delta_chunk(index)
+        if chunk:
+            self.dbtable.delete_row(index)
+            self.update = dict(type ='delete', index = index)            
+            del chunk[index - delta_list] 
+            limit = self.dbtable.limit
+            next_delta_list = delta_list + limit
+            while len(chunk) == limit - 1: #chunk was fully filled                                
+                next_list = self.delta_list.get(next_delta_list)            
+                if next_list:
+                    chunk.append(next_list[0])                        
+                    chunk = next_list
+                    next_delta_list += limit
+                    del next_list[0]
+                else:
+                    last = self.dbtable.read_rows(skip = next_delta_list - 1, limit = 1)[0]
+                    chunk.append(last)                     
+                    #clean dictionary from following elements
+                    self.clean_cache_from(next_delta_list)
+                    break            
+
+    def __len__(self):
+        return len(self.cache) if self.cache is not None else self.dbtable.length
+
+    def append(self, value):
+        if self.cache is not None:
+            self.cache.append(value)
+            return value[-1]
+        index = len(self)
+        id = self.dbtable.append_row(value)            
+        delta_list = index // self.limit * self.limit
+        list = self.delta_list.get(delta_list)
+        if list:
+            list.append(value)
+            self.update = dict(type = 'add', index = index, data = value) 
+        return id
+        
+    def extend(self, rows):
+        start = self.dbtable.length
+        rows = self.dbtable.append_rows(rows)
+        len_rows = len(rows)
+        delta_list_update = start
+        
+        i_rows = 0
+        while len_rows > 0:
+            delta_list = start // self.limit * self.limit
+            list = self.delta_list.get(delta_list)
+            if list is None:            
+                list = []
+                self.delta_list[delta_list] = list
+                can_fill = self.limit
+            else:
+                can_fill = self.limit - len(list)
+            if can_fill:        
+                list.extend(rows[i_rows: i_rows + can_fill])                
+                        
+            i_rows += can_fill           
+            start += can_fill
+            len_rows -= can_fill                            
+        self.update = self.dbtable.get_init_list().update
+
+    def insert(self, index, value):
+        self.append(value)        
+
+    def remove(self, value):
+        index = value[-1]
+        del self[index]
+
+    def pop(self, index = -1):
+        value = self[index]
+        del self[index]
+        return value
+
+    def clear(self):
+        self.dbtable.clear()

unisi/guielements.py

@@ -1,3 +1,5 @@
+from .common import set_defaults
+
 class Gui:
     def __init__(self, name, *args, **kwargs):
         self.name = name
@@ -20,7 +22,7 @@ class Gui:
         else:
             self.value = value
 
-Line = Gui("Line", type = 'line')
+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}
@@ -105,10 +107,7 @@ class Video(Gui):
     def __init__(self,name, *args, **kwargs):
         super().__init__(name, *args, **kwargs)
         self.type = 'video'        
-        if not hasattr(self,'url'):
-            self.url = self.name
-        if not hasattr(self,'ratio'):
-            self.ratio = None
+        set_defaults(self, {'url': self.name, 'ratio' : None})            
 
 class Node:
     def __init__(self, name = '', color = '', size = 0, id = ''):
@@ -141,28 +140,17 @@ class Graph(Gui):
     def __init__(self, name, *args, **kwargs):
         super().__init__(name, *args, **kwargs)
         self.type='graph'
-        if not hasattr(self,'value') or not self.value:
-            self.value = graph_default_value        
-        if not hasattr(self, 'nodes'):
-            self.nodes = []
-        if not hasattr(self, 'edges'):
-            self.edges = []
+        set_defaults(self,{'value': graph_default_value, 'nodes': [], 'edges': []})
         
 class Switch(Gui):
     def __init__(self,name, *args, **kwargs):
         super().__init__(name, *args, **kwargs)        
-        if not hasattr(self,'value'):
-            self.value = False
-        if not hasattr(self,'type'):
-            self.type = 'switch'
+        set_defaults(self,{'value': False, 'type': 'switch'})
 
 class Select(Gui):
     def __init__(self,name, *args, **kwargs):
         super().__init__(name, *args, **kwargs)
-        if not hasattr(self,'options'):             
-            self.options = []
-        if not hasattr(self,'value'):
-            self.value = None
+        set_defaults(self,{'options': [], 'value': None})
         if not hasattr(self, 'type'):
             self.type = 'select' if len(self.options) > 3 else 'radio'        
 
@@ -170,10 +158,7 @@ class Tree(Gui):
     def __init__(self,name, *args, **kwargs):
         super().__init__(name, *args, **kwargs)         
         self.type = 'tree' 
-        if not hasattr(self,'options'):
-            self.options = {}        
-        if not hasattr(self,'value'):
-            self.value = None        
+        set_defaults(self,{'options': [], 'value': None})
         
 class TextArea(Gui):
     def __init__(self,name, *args, **kwargs):