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

unisi/kdb.py

@@ -0,0 +1,336 @@
+import kuzu, shutil, os, re, time
+from datetime import date, datetime
+from cymple import QueryBuilder as qb
+from cymple.typedefs import Properties
+from .common import get_default_args, equal_dicts
+from .dbelements import Dblist
+
+def is_modifying_query(cypher_query):
+    query = cypher_query.lower()
+    modifying_pattern = r'\b(create|delete|detach\s+delete|set|merge|remove|call\s+\w+\s+yield|foreach)\b'        
+    return re.search(modifying_pattern, query)
+
+def query_offset(id, offset):
+    return qb().match().node(id, 'a').where('a.ID','=',offset)  
+
+def kuzu_data_type(value):
+    match value:
+        case bool():
+            return "BOOLEAN"
+        case int():        
+            return "INT64"
+        case float():
+            return "DOUBLE"
+        case str():
+            return "STRING"
+        case datetime():
+            return "TIMESTAMP"        
+        case date():
+            return "DATE"
+        case bytes():
+            return "BLOB"          
+        case list() | tuple():
+            return "LIST"
+        case _:
+            return ""
+
+number_types = ["DOUBLE", "INT64"]
+
+def dict_to_cypher_set(properties, alias = 'a'):
+    set_items = []
+    for key, value in properties.items():
+        if isinstance(value, str):    
+            set_items.append(f"{alias}.{key} = '{value}'")
+        else:
+            set_items.append(f"{alias}.{key} = {value}")        
+    return "SET " + ", ".join(set_items)
+
+class Database:
+    def __init__(self, dbpath, message_logger = print) -> None:    
+        self.db = kuzu.Database(dbpath)
+        self.conn = kuzu.Connection(self.db)
+        self.message_logger = message_logger
+        self.table_params = get_default_args(self.get_table)
+    
+    def execute(self, query_str, ignore_exception = False):
+        query_str = str(query_str)
+        """ if not query_str.endswith(';'):
+            query_str += ';'
+        print(query_str) """
+        try:
+            result = self.conn.execute(query_str)            
+        except Exception as e:
+            if not ignore_exception:
+                self.message_logger(e)
+            return None
+        return True if result is None else result            
+        
+    def delete(dir_path):
+        if os.path.exists(dir_path):
+            # Remove the directory and all its contents
+            shutil.rmtree(dir_path)            
+
+    @property
+    def table_names(self):
+        return self.conn._get_node_table_names()
+    
+    def get_table_fields(self, table_name, remove_id = True) -> None | dict:                            
+        result = self.qlist(f"CALL table_info('{table_name}') RETURN *;", ignore_exception = True)
+        if result is not None:
+            return {info[1]: info[2] for info in result if not remove_id or info[1] != 'ID'}
+
+    def delete_table(self, table_name):        
+        return self.execute( f'DROP TABLE {table_name};')
+            
+    def get_table(self, id = None, limit = 100, headers = None, rows = None, fields = None):        
+        if id:            
+            if rows and fields is None:
+                if not headers:
+                    self.message_logger(f'headers are not defined!')
+                    return None
+                types = [None] * len(headers)                
+                for row in rows:
+                    for j, cell in enumerate(row):
+                        if cell is not None:
+                            ktype = kuzu_data_type(cell)
+                            if ktype:
+                                if types[j] is None:
+                                    types[j] = ktype
+                                elif types[j] != ktype:
+                                    if types[j] in number_types and ktype in number_types:
+                                        types[j] = "DOUBLE"
+                                    else:
+                                        self.message_logger(f'Conflict types for {id} table in {j} column: {types[j], ktype}!')
+                                        return None                    
+                if None in types:
+                    index = types.index(None)
+                    self.message_logger(f'Rows data doesnt contain allowed values for {headers[index]} column!')
+                    return None
+                fields = {headers[i]: type for i, type in enumerate(types)}
+                        
+            if (table_fields := self.get_table_fields(id)) is not None:
+                if not equal_dicts(table_fields, fields):                    
+                    if self.delete_table(id):      
+                        self.message_logger(f'Node table {id} was deleted because of fields contradiction!', 'warning')          
+                else:
+                    return Dbtable(id, self, limit, table_fields)
+                        
+        return self.create_table(id, fields, limit, rows)   
+
+    def get_table_params(self, params):    
+        return {k: v for k, v in params.items() if k in self.table_params}   
+
+    def set_db_list(self, gui_table):
+        table = self.get_table(**self.get_table_params(gui_table.__dict__))
+        tlst = table.list
+        gui_table.rows = tlst
+        if tlst.update['type'] != 'init':
+            tlst.update = dict(type ='init', length = table.length, limit = table.limit, data = tlst.get_delta_0())
+                    
+    def create_table(self, id, fields : dict, limit = 100, rows = None):                
+        specs = ','.join(f'{prop} {type}' for prop, type in fields.items())
+        query = f"CREATE NODE TABLE {id}({specs},ID SERIAL, PRIMARY KEY(ID))"
+        self.execute(query)
+        table = Dbtable(id, self, limit, fields)
+        if rows:
+            table.list.extend(rows)
+        return table
+    
+    def update_row(self, table_id, row_id, props, in_node = True):        
+        set_props = dict_to_cypher_set(props)
+        query = f'MATCH (a: {table_id}) WHERE a.ID = {row_id} {set_props}' if in_node else\
+            f'MATCH ()-[a: {table_id}]->() WHERE a.ID = {row_id} {set_props}'
+        return self.execute(query) 
+        
+    def qlist(self, query, func = None, ignore_exception = False):                
+        if answer := self.execute(query, ignore_exception):            
+            result = []
+            while answer.has_next():
+                value = answer.get_next()
+                result.append(func(value) if func else value)
+            return result
+    
+    def qiter(self, query, func = None, ignore_exception = False):        
+        answer = self.execute(query, ignore_exception)
+        while answer.has_next():
+            value = answer.get_next()
+            yield func(value) if func else value        
+            
+class Dbtable:
+    def __init__(self, id, db, limit = 100, table_fields = None) -> None:        
+        self.db = db
+        self.id = id              
+        self.table_fields = table_fields
+        self.limit = limit    
+        self.node_columns = list(db.conn._get_node_property_names(id).keys())[:-1]            
+        self.init_list()          
+
+    @property
+    def rel_table_names(self):
+        return self.db.conn._get_rel_table_names() 
+    
+    def default_index_name2(self, link_table):
+        return f'{self.id}2{link_table}'
+    
+    def calc_linked_rows(self,  index_name, link_ids, include_rels = False, search = ''):
+        #condition = ' OR '.join(f'b.ID = {id}' for id in link_ids) #bug in IN op!
+        condition = f'b.ID in {link_ids}'
+        rel_info = ', r.*' if include_rels else ''
+        query = f"""
+            MATCH (a:{self.id})-[r:{index_name}]->(b:User)
+            WHERE {condition}
+            RETURN a.*{rel_info}
+            ORDER BY a.ID ASC
+        """        
+        lst = self.db.qlist(query)         
+        return Dblist(self, cache = lst)
+        
+    def get_rel_fields2(self, tname, fields : dict = None, relname = None):
+        """return name of link table and fields and its fields dict"""
+        if not relname:
+            relname = self.default_index_name2(tname)
+        rel_table_fields = self.db.get_table_fields(relname)
+        if isinstance(rel_table_fields, dict):
+            if isinstance(fields, dict):
+                if equal_dicts(rel_table_fields, fields):
+                    return relname, rel_table_fields
+                else:
+                    self.db.delete_table(relname)            
+            else:
+                fields = rel_table_fields
+        elif fields is None:
+            fields = {}
+
+        if not any(info['name']  == relname for info in self.rel_table_names):                        
+            fprops = ''.join(f', {field} {type}' for field, type in fields.items()) if fields else ''
+            fprops += ', ID SERIAL'
+            query = f"CREATE REL TABLE {relname}(FROM {self.id} TO {tname} {fprops})"
+            self.db.execute(query)
+            self.rel_table_names.append({'name' : relname})
+        return relname, fields
+    
+    def add_link(self, snode_id, link_table, tnode_id, link_fields = None, link_index_name = None):
+        """return added link"""
+        if link_index_name is None:
+            link_index_name = self.default_index_name2(link_table)
+        if link_fields is None:
+            link_fields = {}
+        query = f"""
+            MATCH (a:{self.id}), (b:{link_table})
+            WHERE a.ID = {snode_id} AND b.ID = {tnode_id}
+            CREATE (a)-[r:{link_index_name} {{{Properties(link_fields)}}}]->(b)            
+            RETURN r.*
+            """
+        lst = self.db.qlist(query)
+        return lst[0]
+    
+    def add_links(self, link_table, snode_ids : iter, tnode_id, link_index_name = None):
+        result = []
+        for id in snode_ids:
+            result.append(self.add_link(id, link_table, tnode_id, link_index_name = link_index_name))
+        return result
+    
+    def delete_link(self, link_table_id, link_id, index_name = None):
+        if not index_name:
+            index_name = self.default_index_name2(link_table_id)
+        query = f"""
+        MATCH (:{self.id})-[r:{index_name}]->(:{link_table_id})
+        WHERE r.ID = {link_id}
+        DELETE r
+        """
+        self.db.execute(query)
+
+    def delete_links(self, link_table_id, link_node_id = None, source_ids = None, link_ids = None, index_name = None):
+        if not index_name:
+            index_name = self.default_index_name2(link_table_id)
+        
+        if link_ids:
+            condition = f'r.ID in {link_ids}'
+            #condition = ' OR '.join(f'r.ID = {id}' for id in link_ids) #bug in IN op!
+        else:
+            if not isinstance(source_ids, list):
+                source_ids = list(source_ids)
+            #condition = ' OR '.join(f'a.ID = {id}' for id in source_ids) #bug in IN op!
+            condition = f'a.ID in {source_ids}'
+            condition = f'({condition}) AND b.ID = {link_node_id}'
+        query = f"""
+        MATCH (a:{self.id})-[r:{index_name}]->(b:{link_table_id})
+        WHERE {condition}
+        DELETE r
+        """
+        self.db.execute(query)
+
+    def init_list(self):                
+        list = self.read_rows(limit = self.limit)
+        length = len(list)
+        #possibly the table has more rows        
+        if length == self.limit:
+            #qresult = self.db.execute()   
+            ql = self.db.qlist(f"MATCH (n:{self.id}) RETURN count(n)")
+            self.length = ql[0][0]
+        else:
+            self.length = length
+        self.list = Dblist(self, list)
+
+    def get_init_list(self, search_string = None):
+        lst = self.list
+        lst.update = dict(type ='init', length = self.length, 
+            limit = self.limit, data = self.list.get_delta_0())
+        return lst
+        
+    def read_rows(self, skip = 0, limit = 0):
+        query = qb().match().node(self.id, 'a').return_literal('a.*').order_by('a.ID')
+        if skip:
+            query = query.skip(skip)
+        query = query.limit(limit if limit else self.limit)
+        return self.db.qlist(query)    
+
+    def assign_row(self, row_array):
+        return self.db.update_row(self.id, row_array[-1], {name : value for name, value in zip(self.node_columns, row_array)})
+
+    def delete_row(self, id):
+        query = query_offset(self.id, id)
+        self.length -= 1
+        return self.db.execute(query.detach_delete('a'))
+    
+    def delete_rows(self, ids):
+        #condition = ' OR '.join(f'a.ID = {id}' for id in ids) #bug in IN op!
+        condition = f'a.ID in {ids}'
+        query = f"""
+        MATCH (a:{self.id})
+        WHERE {condition}
+        DELETE a
+        """
+        return self.db.execute(query)
+    
+    def append_row(self, row):
+        """row can be list or dict, returns ID"""        
+        if isinstance(row, list):
+            props = {name: value for name, value in zip(self.node_columns, row) if value is not None}
+        try:                
+            answer = self.db.execute(qb().create().node(self.id, 'a', props).return_literal('a.ID'))
+        except Exception as e:
+            return None
+        if answer.has_next():                        
+            self.length += 1
+            return answer.get_next()[0]
+        return None
+    
+    def append_rows(self, rows):
+        """row can be list or dict"""
+        rows_arr = []
+        for row in rows:            
+            row = {name: value for name, value in zip(self.node_columns, row)} if not isinstance(row, dict) else row
+            srow = f' {{{Properties(row).to_str()}}}'
+            rows_arr.append(srow)      
+        rows_arr = ','.join(rows_arr)      
+        
+        query = (qb().with_(f'[{rows_arr}] AS rows')
+            .unwind('rows AS row')
+            .create()
+            .node(self.id, 'n', {p: f'row.{p}' for p in self.node_columns}, escape=False)
+            .return_literal('n.*'))
+        
+        self.length += len(rows)        
+        return self.db.qlist(query)  
+

unisi/multimon.py

@@ -17,12 +17,14 @@ def multiprocessing_pool():
         _multiprocessing_pool = multiprocessing.Pool(pool)
     return _multiprocessing_pool
 
-async def run_external_process(long_running_task, *args, queue = None, progress_callback = None, **kwargs):
+async def run_external_process(long_running_task, *args, progress_callback = None, **kwargs):
     if progress_callback:
-        if queue is None:
+        if args[-1] is None:
             queue = multiprocessing.Manager().Queue()
-        if args[-1] is None:                    
-            args = *args[:-1], queue            
+            args = *args[:-1], queue
+        else:
+            queue = args[-1] 
+                        
     result = multiprocessing_pool().apply_async(long_running_task, args, kwargs)
     if progress_callback:
         while not result.ready() or not queue.empty():            
@@ -44,7 +46,7 @@ def monitor_process(monitor_shared_arr):
     while True:
         #Wait for data in the shared array
         while monitor_shared_arr[0] == b'\x00':
-            time.sleep(0.005)  
+            time.sleep(monitor_tick)  
             if timer is not None:
                 timer -= monitor_tick                
                 if timer < 0:

unisi/reloader.py

@@ -15,8 +15,8 @@ if config.hot_reload:
     import os, sys, traceback
     from watchdog.observers import Observer
     from watchdog.events import PatternMatchingEventHandler
-    from .users import User
-    from .utils import divpath, Redesign, app_dir
+    from .users import User, Redesign
+    from .utils import divpath, app_dir
     from .autotest import check_module
     import re, collections
 

unisi/server.py

@@ -88,7 +88,15 @@ async def websocket_handler(request):
         await user.delete()   
     return ws     
 
+def ensure_directory_exists(directory_path):
+    if not os.path.exists(directory_path):
+        os.makedirs(directory_path)
+        print(f"Directory '{directory_path}' created.")
+
 def start(appname = None, user_type = User, http_handlers = []):    
+    ensure_directory_exists(screens_dir)
+    ensure_directory_exists(blocks_dir)
+
     if appname:
         config.appname = appname
 
@@ -101,7 +109,7 @@ def start(appname = None, user_type = User, http_handlers = []):
     http_handlers += [web.static(f'/{config.upload_dir}', upload_dir), 
         web.get('/{tail:.*}', static_serve), web.post('/', post_handler)]
 
-    print(f'Start {appname} web server..')    
+    #print(f'Start {appname} web server..')    
     app = web.Application()
     app.add_routes(http_handlers)    
     web.run_app(app,  port=port)

unisi/tables.py

@@ -1,75 +1,199 @@
 from .guielements import Gui
+from .common import references, set_defaults, Warning, pretty4
+from .dbelements import Dblist
 
-def accept_cell_value(table, val):    
-    value, position = val
+relation_mark = 'Ⓡ'
+exclude_mark = '✘'
+
+def iterate(iter, times):
+    for i, val in enumerate(iter):
+        if i == times:
+            return val
+
+def accept_cell_value(table, dval):        
+    value = dval['value']
     if not isinstance(value, bool):
         try:
             value = float(value)        
-        except ValueError:
-            return
-    table.rows[position[0]][position[1]] = value    
-
-def delete_table_row(table, value):
-    if table.rows:        
-        keyed = len(table.headers) < len(table.rows[0])
-        table.value = value   
-        if isinstance(value, list):        
-            if keyed:
-                table.rows = [row for row in table.rows if row[-1] not in value]
-            else:
-                value.sort(reverse=True)
-                for v in value:            
-                    del table.rows[v]
-            table.value = []
+        except:
+            pass            
+    if hasattr(table,'id'):
+        dbt = table.rows.dbtable
+        in_node, field = table.index2node_relation(dval['cell'])                    
+        if in_node:
+            table_id = table.id 
+            row_id =  table.rows[dval['delta']][len(dbt.table_fields)] 
         else:
-            if keyed:            
-                table.rows = [row for row in table.rows if row[-1] != value]
-            else:
-                del table.rows[value]  
+            table_id = table.__link__[2]
+            row_id = dval['id']             
+        dbt.db.update_row(table_id, row_id, {field: value}, in_node)
+    
+    table.rows[dval['delta']][dval['cell']] = value    
+            
+def delete_table_row(table, value):    
+    if table.selected_list:
+        if hasattr(table, 'link') and table.filter:
+            link_table, rel_props, rel_name = table.__link__        
+            if not isinstance(value, list):                                
+                value = [value]
+            table.rows.dbtable.delete_links(link_table.id, link_ids = value, index_name = rel_name)
+            table.__link_table_selection_changed__(link_table, link_table.value)
+            return table
+        elif isinstance(value, list):                    
+            value.sort(reverse = True)
+            for v in value:            
+                del table.rows[v]
+            table.value = []
+        else:            
+            del table.rows[value]  
             table.value = None    
 
-def append_table_row(table, value):
-    ''' append has to return new row or error string, val is search string in the table'''
-    new_id_row, search = value #new_id_row == rows count
-    new_row = [''] * len(table.headers)
-    if search:
-        new_row[0] = search
+def append_table_row(table, search_str):
+    ''' append has to return new row, value is the search string value in the table'''    
+    new_row = [None] * len(table.rows.dbtable.table_fields)           
+    if getattr(table,'id', None):          
+        id = table.rows.dbtable.list.append(new_row)
+        new_row.append(id)         
+        if hasattr(table, 'link') and table.filter:
+            link_table, _, rel_name = table.__link__               
+            for linked_id in link_table.selected_list:
+                relation = table.rows.dbtable.add_link(id, link_table.id, linked_id, link_index_name = rel_name) 
+                new_row.extend(relation)                     
+                break                 
     table.rows.append(new_row)
     return new_row
 
+def get_chunk(obj, start_index):
+    delta, data = obj.rows.get_delta_chunk(start_index)
+    return {'type': 'updates', 'index': delta, 'data': data}
+
 class Table(Gui):
     def __init__(self, *args, panda = None, **kwargs):
         if panda is not None:
             self.mutate(PandaTable(*args, panda=panda, **kwargs))
         else:
-            super().__init__(*args, **kwargs)           
-            if not hasattr(self,'headers'):
-                self.headers = []
-            if not hasattr(self,'type'):
-                self.type = 'table'
-            if not hasattr(self,'value'):
-                self.value = None
-            if not hasattr(self,'rows'):
-                self.rows = []        
-            if not hasattr(self,'dense'):
-                self.dense = True
+            super().__init__(*args, **kwargs)    
+            set_defaults(self, dict(headers = [], type = 'table', value = None, rows = [], editing = False, dense = True))
+            self.__headers__ = self.headers[:]
+        if getattr(self,'id', None): 
+            db = references.context_user().db
+            if db:
+                db.set_db_list(self)
+            else:
+                raise AssertionError('Config db_dir is not defined!')            
+            self.get = get_chunk
+            has_link = hasattr(self, 'link')
+            set_defaults(self, {'filter': has_link, 'ids': False, 'search': ''})
+            if has_link: 
+                prop_types = {}
+                rel_name = ''                
+                match self.link:
+                    case [link_table, prop_types, rel_name]: ...
+                    case [link_table, prop_types]: ...
+                    case link_table: ...
+                rel_name, rel_fields = self.rows.dbtable.get_rel_fields2(link_table.id, prop_types, rel_name)
+                if not hasattr(link_table, 'id'):
+                    raise AttributeError('Linked table has to be persistent!')
+                self.__link__ = link_table, list(prop_types.keys()), rel_name
+                self.link = rel_fields
+                
+                @references.handle(link_table,'changed')
+                def link_table_selection_changed(master_table, val, init = False):
+                    lstvalue = val if isinstance(val, list) else [val] if val != None else []
+                    if lstvalue:
+                        link_ids = [link_table.rows[val][-1] for val in lstvalue]
+                        link_rows = self.rows.dbtable.calc_linked_rows(rel_name, link_ids, self.filter, self.search)
+                    else:
+                        link_rows = Dblist(self.rows.dbtable, cache = [])
+                    if self.filter:                    
+                        self.clean_selection()
+                        self.rows = link_rows
+                    else: 
+                        selected_ids = [link_rows[i][-1] for i in range(len(link_rows))]
+                        self.value = selected_ids
+                        #restore table rows if they are not rows
+                        if self.rows.cache is not None:
+                           self.rows = self.rows.dbtable.get_init_list()
+                    if not init:
+                        master_table.accept(val)              
+                        return self     
+                link_table_selection_changed(link_table, link_table.value, True)
+                self.__link_table_selection_changed__ = link_table_selection_changed
+
+                @references.handle(self,'filter')
+                def filter_status_changed(table, value):
+                    self.filter = value
+                    link_table_selection_changed(link_table, link_table.value, True)
+                    self.calc_headers()
+                    return self                
+                
+                @references.handle(self,'changed')
+                def changed_selection_causes__changing_links(self, new_value):                   
+                    if link_table.value is not None and link_table.value != []:
+                        #if link table is in multi mode, links are not editable 
+                        if not self.filter and not isinstance(link_table.value, list | tuple):
+                            if  self.editing:
+                                actual = set(new_value if isinstance(new_value, list) else [] if new_value is None else [new_value])
+                                old = set(self.value if isinstance(self.value, list) else ([] if self.value is None else [self.value]))                        
+                                deselected = old - actual                        
+                                if deselected:
+                                    self.rows.dbtable.delete_links(link_table.id, link_table.value, deselected)                            
+                                selected = actual - old
+                                if selected:
+                                    self.rows.dbtable.add_links(link_table.id, selected, link_table.value)                                                        
+                            else:
+                                return Warning('The linked table is not in edit mode', self)
+                    return self.accept(new_value)    
+                
+            @references.handle(self,'search')
+            def search_changed(table, value):
+                self.search = value
+                if has_link:
+                    link_table_selection_changed(link_table, link_table.value, True)
+                else:
+                    self.rows = self.rows.dbtable.get_init_list(self.search)
+                return self
+                
+            self.calc_headers()                                
+                    
+        elif hasattr(self,'ids'):
+            raise ValueError("Only persistent tables can have 'ids' option!")
 
         if getattr(self,'edit', True): 
-            if not hasattr(self,'delete'):
-                self.delete = delete_table_row             
-            if not hasattr(self,'append'):
-                self.append = append_table_row             
-            if not hasattr(self,'modify'):
-                self.modify = accept_cell_value             
-        
+            set_defaults(self,{'delete': delete_table_row, 'append': append_table_row, 'modify': accept_cell_value})             
+                
+    @property
     def selected_list(self):                            
         return [self.value] if self.value != None else [] if type(self.value) == int else self.value   
 
-    def clean(self):
-        self.rows = []
-        self.value = [] if isinstance(self.value,(tuple, list)) else None
+    def clean_selection(self):        
+        self.value = [] if isinstance(self.value,tuple | list) else None
         return self
+    
+    def calc_headers(self):        
+        """only for persistent"""
+        table_fields = self.rows.dbtable.table_fields
+        self.headers = self.__headers__[:] if self.__headers__ else [pretty4(prop)for prop in table_fields]
+        only_node_headers = len(self.headers) == len(table_fields)
+        if self.ids:
+            self.headers.insert(len(table_fields), 'ID')
+        elif self.filter:
+            self.headers.insert(len(table_fields), exclude_mark + 'ID')
+        if self.filter:
+            if only_node_headers:
+                self.headers.extend([relation_mark + pretty4(link_field) for link_field in self.link])
+            if self.ids:
+                self.headers.append(relation_mark + 'ID')
 
+    def index2node_relation(self, cell_index):
+        """calculate delta to property of node or link for persistent"""
+        table_fields = self.rows.dbtable.table_fields
+        delta = cell_index - len(table_fields)       
+        if delta < 0:            
+            return True, iterate(table_fields, cell_index)
+        delta -= 1 #ID field
+        return False, iterate(self.link, delta)
+        
 def delete_panda_row(table, row_num):    
     df = table.__panda__
     if row_num < 0 or row_num >= len(df):
@@ -99,17 +223,13 @@ class PandaTable(Table):
             raise Exception('PandaTable has to get panda = pandaTable as an argument.')
         self.headers = panda.columns.tolist()
         if fix_headers:
-            self.headers = [header.replace('_',' ') for header in self.headers]        
+            self.headers = [pretty4(header) for header in self.headers]        
         self.rows = panda.values.tolist()
         self.__panda__ = panda
 
         if getattr(self,'edit', True): 
-            if not hasattr(self,'delete'):
-                self.delete = delete_panda_row             
-            if not hasattr(self,'append'):
-                self.append = append_panda_row             
-            if not hasattr(self,'modify'):
-                self.modify = accept_panda_cell            
+            set_defaults(self,{'delete': delete_panda_row, 'append': append_panda_row,
+                'modify': accept_panda_cell})
     @property
     def panda(self):
         return getattr(self,'__panda__',None)