unisi 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

unisi/autotest.py

@@ -1,4 +1,4 @@
-import config, os, logging, json, asyncio
+import config, os, json, asyncio
 from .utils import *
 from .units import * 
 from .containers import Block, Dialog

unisi/containers.py

@@ -50,8 +50,7 @@ class Block(Unit):
                     exactly = True
                 elif isinstance(elem.llm, dict):
                     if elem.type != 'table':                        
-                        raise AttributeError(f'{elem.name} llm parameter is a dictionary only for tables, not for {elem.type}!')                                            
-                    
+                        raise AttributeError(f'{elem.name} llm parameter is a dictionary only for tables, not for {elem.type}!')                                                                
                     elem.__llm_dependencies__ = {fld: (deps if isinstance(deps, list | bool) else [deps]) for fld, deps in elem.llm.items()} 
                     elem.llm = True
                     continue
@@ -67,8 +66,8 @@ class Block(Unit):
                     print(f'Empty dependency list for llm calculation for {elem.name} {elem.type}!')
                 
     @property
-    def compact_view(self):
-        return [obj for obj in flatten(self.value) if obj.value is not None]        
+    def compact_view(self) -> str:
+        return ','.join(obj.compact_view for obj in flatten(self.value) if obj.value)
 
     @property
     def scroll_list(self):            

unisi/dbunits.py

@@ -1,25 +1,15 @@
 from .common import Unishare
-import asyncio
 from collections import defaultdict
 
 #storage id -> screen name -> [elem name, block name]
 dbshare = defaultdict(lambda: defaultdict(lambda: []))
-#db id -> update
+# db id -> [update]
 dbupdates = defaultdict(lambda: [])
 
-async def sync_dbupdates():
-    sync_calls = []
-    for id, updates in dbupdates.items():
-        for update in updates:
-            screen2el_bl = dbshare[id]
-            for user in Unishare.sessions.values():
-                scr_name = user.screen.name
-                if scr_name in screen2el_bl:
-                    for elem_block in screen2el_bl[scr_name]: #optim--                        
-                        update4user = {**update, **elem_block.__dict__}
-                        sync_calls.append(user.send(update4user))
-    dbupdates.clear()
-    await asyncio.gather(*sync_calls)
+def at_iter(iter, times):
+    for i, val in enumerate(iter):
+        if i == times:
+            return val
     
 class Dblist:
     def __init__(self, dbtable, init_list = None, cache = None):                
@@ -31,22 +21,17 @@ class Dblist:
             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) 
+        self.dbtable = dbtable                        
 
     def get_delta_0(self):
-        return self.delta_list[0]
+        return self.delta_list[0] if self.cache is None else self.cache[:self.limit]
 
-    def __getattribute__(self, name):
-        if name == '__dict__':
-            return object.__getattribute__(self, 'update')
-        return object.__getattribute__(self, name)
+    def __getstate__(self):        
+        return dict(length = len(self),  limit = self.limit, data = self.get_delta_0())
     
     def __getattr__(self, name):
         return self.dbtable.limit if name == 'limit' else None
         
-    """ The methods causes invalid serialization in Python and not used!
     def __iter__(self):
         "Override the default iterator to provide custom behavior."
         self._index = 0
@@ -59,12 +44,12 @@ class Dblist:
             return value
         else:
             raise StopIteration
-    """
-    
+           
     def __str__(self):
-        return f'\ndeltas: {self.delta_list}\nupdate: {self.update}'        
+        return str(self.__getstate__())
         
-    def get_delta_chunk(self, index):
+    def get_delta_chunk(self, index) -> tuple[int, list]:
+        """return delta list and chunk of data"""
         if index >= len(self):
             return -1, None
         delta_list = index // self.limit * self.limit
@@ -79,22 +64,25 @@ class Dblist:
         self.delta_list[delta_list] = lst        
         return delta_list, lst
 
-    def __getitem__(self, index):        
+    def __getitem__(self, index) -> list:
+        """return row from delta list or cache"""
         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):
+    def __setitem__(self, index, value: list):
+        """update row in delta list or cache"""
         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)
+                chunk[index - delta_list] = value            
             self.dbtable.assign_row(value)
+            update = dict(update = 'update', index = index, data = value)
+            dbupdates[self.dbtable.id].append(update)            
 
     def clean_cache_from(self, delta_list):
         """clear dirty delta_list cache"""
@@ -104,38 +92,61 @@ class Dblist:
         delta_list, chunk = self.get_delta_chunk(index)
         if chunk:
             self.dbtable.delete_row(index)
-            self.update = dict(type ='delete', index = index)            
+            update = dict(update ='delete', index = index, exclude = True)            
+            dbupdates[self.dbtable.id].append(update)
             del chunk[index - delta_list] 
             limit = self.dbtable.limit
             next_delta_list = delta_list + limit
             if 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])                                                               
-                else:
-                    delta_list, chunk = self.get_delta_chunk(delta_list)                    
-                    self.update = dict(type = 'updates', index = delta_list, data = chunk)
-                self.clean_cache_from(next_delta_list)                     
+                    chunk.append(next_list[0])                                                                               
+                self.clean_cache_from(next_delta_list)            
 
     def __len__(self):
         return len(self.cache) if self.cache is not None else self.dbtable.length
+    
+    def index2node_relation(self, cell_index):
+        """calculate delta to property of node or link for persistent"""
+        table_fields = self.dbtable.table_fields
+        delta = cell_index - len(table_fields)       
+        if delta < 0:            
+            return True, at_iter(table_fields, cell_index)
+        delta -= 1 #ID field
+        return False, at_iter(self.dbtable.list.link[1], delta)
+    
+    def update_cell(self, delta, cell, value, id = None) -> dict:
+        in_node, field = self.index2node_relation(cell)                    
+        if in_node:
+            table_id = self.dbtable.id 
+            row_id =  self[delta][len(self.dbtable.table_fields)] 
+        else:
+            table_id = self.dbtable.list.link[2]
+            row_id = id
+        self.dbtable.db.update_row(table_id, row_id, {field: value}, in_node) 
+        self[delta][cell] = value
+        if self.cache is None: 
+            update = dict(update = 'update', index = delta, data = self[delta])
+            dbupdates[self.dbtable.id].append(update)        
+            return update
 
-    def append(self, value):
+    def append(self, arr):
+        """append row to list"""
         if self.cache is not None:
-            self.cache.append(value)
-            return value[-1]
+            self.cache.append(arr)
+            return arr
         index = len(self)
-        id = self.dbtable.append_row(value)            
-        delta_list = index // self.limit * self.limit
-        list = self.delta_list.get(delta_list)
+        row = self.dbtable.append_row(arr)                    
+        delta_chunk,list = self.get_delta_chunk(index)
         if list:
-            list.append(value)
-            self.update = dict(type = 'add', index = index, data = value) 
-        return id
+            list.append(row)
+            update = dict(update = 'add', index = index, data = row) 
+            dbupdates[self.dbtable.id].append(update)
+            return row
         
-    def extend(self, rows):
-        start = self.dbtable.length
-        delta_start = start // self.limit * self.limit
+    def extend(self, rows) -> dict:
+        delta_start = self.dbtable.length
+        start = delta_start
         rows = self.dbtable.append_rows(rows)
         len_rows = len(rows)                
         i_rows = 0
@@ -155,10 +166,10 @@ class Dblist:
             i_rows += can_fill           
             start += can_fill
             len_rows -= can_fill        
-        delta, data = self.get_delta_chunk(delta_start)
-        self.update = dict(type = 'updates', index = delta, data = data, length = length)
-        return self.update
-
+        delta, data = self.get_delta_chunk(delta_start)        
+        update = dict(update = 'updates', index = delta, data = data, length = length)
+        dbupdates[self.dbtable.id].append(update)        
+    
     def insert(self, index, value):
         self.append(value)        
 
@@ -171,5 +182,7 @@ class Dblist:
         del self[index]
         return value
 
-    def clear(self):
-        self.dbtable.clear()
+    def clear(self, detach = False):
+        self.dbtable.clear(detach)
+        self.delta_list = {0: None}
+        dbupdates[self.dbtable.id].append(dict(update = 'updates', length = 0))        

unisi/kdb.py

@@ -49,6 +49,7 @@ def dict_to_cypher_set(properties, alias = 'a'):
     return "SET " + ", ".join(set_items)
 
 class Database:
+    tables = {} #id -> Dbtable
     def __init__(self, dbpath, message_logger = print) -> None:    
         self.db = kuzu.Database(dbpath)
         self.conn = kuzu.Connection(self.db)
@@ -116,7 +117,7 @@ class Database:
                     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.tables.get(id) or Dbtable(id, self, limit, table_fields)
                         
         return self.create_table(id, fields, limit, rows)   
 
@@ -126,9 +127,7 @@ class Database:
     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())
+        gui_table.rows = tlst        
                     
     def create_table(self, id, fields : dict, limit = 100, rows = None):                
         specs = ','.join(f'{prop} {type}' for prop, type in fields.items())
@@ -162,6 +161,7 @@ class Database:
 class Dbtable:
     def __init__(self, id, db, limit = 100, table_fields = None) -> None:        
         self.db = db
+        db.tables[id] = self
         self.id = id              
         self.table_fields = table_fields
         self.limit = limit    
@@ -250,9 +250,8 @@ class Dbtable:
             condition = f'r.ID in {link_ids}'            
         else:
             if not isinstance(source_ids, list):
-                source_ids = list(source_ids)            
-            condition = f'a.ID in {source_ids}'
-            condition = f'({condition}) AND b.ID = {link_node_id}'
+                source_ids = list(source_ids)                        
+            condition = f'(a.ID in {source_ids}) AND b.ID = {link_node_id}'
         query = f"""
         MATCH (a:{self.id})-[r:{index_name}]->(b:{link_table_id})
         WHERE {condition}
@@ -264,19 +263,12 @@ class Dbtable:
         list = self.read_rows(limit = self.limit)
         length = len(list)
         #possibly the table has more rows        
-        if length == self.limit:
-            #qresult = self.db.execute()   
+        if length == self.limit:            
             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')
@@ -286,7 +278,8 @@ class Dbtable:
         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)})
+        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)
@@ -302,17 +295,24 @@ class Dbtable:
         """
         return self.db.execute(query)
     
+    def clear(self, detach = False):
+        query = f'MATCH (a:{self.id})'
+        if detach:
+            query += ' DETACH DELETE a'
+        else:
+            query += ' DELETE a'
+        self.length = 0
+        return self.db.execute(query)
+    
     def append_row(self, row):
-        """row can be list or dict, returns ID"""        
+        """row can be list or dict, returns new row"""        
         if isinstance(row, list):
             props = {name: value for name, value in zip(self.node_columns, row) if value is not None}
                       
-        answer = self.db.execute(qb().create().node(self.id, 'a', props).return_literal('a.ID'))
-        
+        answer = self.db.execute(qb().create().node(self.id, 'a', props).return_literal('a.*'))        
         if answer and answer.has_next():                        
             self.length += 1
-            return answer.get_next()[-1]
-        return None
+            return answer.get_next()        
     
     def append_rows(self, rows):
         """row can be list or dict"""

unisi/llmrag.py

@@ -1,14 +1,20 @@
 from .common import Unishare
 from langchain_groq import ChatGroq
 from langchain_openai import ChatOpenAI
+from langchain_google_genai import (
+    ChatGoogleGenerativeAI,
+    HarmBlockThreshold,
+    HarmCategory,
+)
 
 def setup_llmrag():    
     import config #the module is loaded before config.py    
+    temperature = getattr(config, 'temperature', 0.0)
     if config.llm:
         match config.llm:
             case ['host', address]: 
                 model = None
-                type = 'openai' #provider type is openai for local llms
+                type = 'host' #provider type is openai for local llms
             case [type, model, address]: ...
             case [type, model]: address = None
             case _:
@@ -16,25 +22,39 @@ def setup_llmrag():
                 return
                 
         type = type.lower()
-        if type == 'openai':            
-            Unishare.llm_model = ChatOpenAI(
-                api_key = 'llm-studio',
-                temperature = 0.0,
-                openai_api_base = address
-            ) if address else ChatOpenAI(temperature=0.0)
+        match type:
+            case 'host':            
+                Unishare.llm_model = ChatOpenAI(
+                    api_key = 'llm-studio',
+                    temperature = temperature,
+                    openai_api_base = address
+                ) 
+            case 'openai':
+                Unishare.llm_model = ChatOpenAI(temperature=0.0)
 
-        elif type == 'groq':
-            Unishare.llm_model = ChatGroq(
-                model = model,
-                temperature = 0.0,
-                max_tokens = None,
-                timeout = None,
-                max_retries = 2, 
-            )
+            case 'groq':
+                Unishare.llm_model = ChatGroq(
+                    model = model,
+                    temperature = temperature,
+                    max_tokens = None,
+                    timeout = None,
+                    max_retries = 2, 
+                )
+            case 'google' | 'gemini':
+                Unishare.llm_model = ChatGoogleGenerativeAI(
+                    model = model,
+                    temperature = temperature,
+                    max_tokens = None,
+                    timeout = None,
+                    max_retries = 2,
+                    safety_settings = {
+                        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE
+                    }
+                )
 
 numeric_types = ['number', 'int', 'float', 'double']
 
-async def get_property(name, json_context = '', type = 'string', options = None, attempts = 1, messages = None):
+async def get_property(name, context = '', type = 'string', options = None, attempts = 1, messages = None):
     if messages is None:
         limits = f'type is {type}'
         if type == 'date':
@@ -44,9 +64,9 @@ async def get_property(name, json_context = '', type = 'string', options = None,
         messages = [
             (
                 "system",
-                f"""You are an intelligent and extremely concise assistant."""        
+                f"""You are an intelligent and extremely smart assistant."""        
             ),
-            ("user",  f"""{json_context} Reason and infer the "{name}" value, which {limits}. 
+            ("human",  f"""{context} . Reason and infer {name}, which {limits}. 
                 Do not include any additional text or commentary in your answer, just exact the property value.""")
         ]
     ai_msg =  await Unishare.llm_model.ainvoke(messages)
@@ -64,7 +84,7 @@ async def get_property(name, json_context = '', type = 'string', options = None,
     if not log_error and options and value not in options:
         attempts -= 1
         if attempts > 0:
-            value = get_property(name, json_context, type, options, attempts, messages)
+            value = get_property(name, context, type, options, attempts, messages)
         else:
             log_error = f'Invalid value {value} from llm-rag for {messages[1][1]}'
 

unisi/server.py

@@ -5,7 +5,7 @@ from .reloader import empty_app
 from .autotest import recorder, run_tests
 from .common import  *
 from.llmrag import setup_llmrag
-from .dbunits import dbupdates, sync_dbupdates
+from .dbunits import dbupdates
 from config import port, upload_dir
 import traceback, json
 
@@ -82,7 +82,7 @@ async def websocket_handler(request):
                                 recorder.accept(message, user.prepare_result (result))
                             await user.reflect(message, result)     
                         if dbupdates:
-                            await sync_dbupdates()                       
+                            await user.sync_dbupdates()                       
                 elif msg.type == WSMsgType.ERROR:
                     user.log('ws connection closed with exception %s' % ws.exception())
         except BaseException as e:

unisi/tables.py

@@ -3,6 +3,7 @@ from .common import *
 from .dbunits import Dblist, dbupdates
 from .llmrag import get_property
 import asyncio
+from collections import OrderedDict
 
 relation_mark = 'Ⓡ'
 exclude_mark = '✘'
@@ -10,14 +11,9 @@ max_len_rows4llm = 30
 
 def get_chunk(obj, start_index):
     delta, data = obj.rows.get_delta_chunk(start_index)
-    return {'type': 'updates', 'index': delta, 'data': data}
+    return {'update': 'updates', 'index': delta, 'data': data}
 
-def iterate(iter, times):
-    for i, val in enumerate(iter):
-        if i == times:
-            return val
-
-def accept_cell_value(table, dval):        
+def accept_cell_value(table, dval):            
     value = dval['value']
     if not isinstance(value, bool):
         try:
@@ -25,24 +21,20 @@ def accept_cell_value(table, dval):
         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:
-            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    
+        dval['value'] = value
+        if update := table.rows.update_cell(**dval):
+            update['exclude'] = True       
+    else:        
+        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__        
+            link_table, rel_props, rel_name = table.rows.dbtable.list.link
             if not isinstance(value, list):                                
                 value = [value]
-            table.rows.dbtable.delete_links(link_table.id, link_ids = value, index_name = rel_name)
+            link_ids = [table.rows[index][-1] for index in value]
+            table.rows.dbtable.delete_links(link_table.id, link_ids = link_ids, index_name = rel_name)
             table.__link_table_selection_changed__(link_table, link_table.value)
             return table
         elif isinstance(value, list):                    
@@ -54,16 +46,16 @@ def delete_table_row(table, value):
             del table.rows[value]  
             table.value = None    
 
-def append_table_row(table, search_str):
+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)         
+        new_row = table.rows.dbtable.list.append(new_row)        
         if hasattr(table, 'link') and table.filter:
-            link_table, _, rel_name = table.__link__               
+            link_table, _, rel_name = table.rows.dbtable.list.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) 
+                relation = table.rows.dbtable.add_link(new_row[-1], link_table.id,
+                     linked_id, link_index_name = rel_name) 
                 new_row.extend(relation)                     
                 break                 
     table.rows.append(new_row)
@@ -95,7 +87,7 @@ class Table(Unit):
                 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.rows.link = link_table, list(prop_types.keys()), rel_name
                 self.link = rel_fields
                 
                 @Unishare.handle(link_table,'changed')
@@ -111,10 +103,9 @@ class Table(Unit):
                         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
+                        self.value = selected_ids  
                         if self.rows.cache is not None:
-                           self.rows = self.rows.dbtable.get_init_list()
+                            self.rows = self.rows.dbtable.list
                     if not init:
                         master_table.accept(val)              
                         return self     
@@ -145,7 +136,7 @@ class Table(Unit):
                             else:
                                 return Warning('The linked table is not in edit mode', self)
                     return self.accept(new_value)    
-                
+            """
             @Unishare.handle(self,'search')
             def search_changed(table, value):
                 self.search = value
@@ -154,7 +145,7 @@ class Table(Unit):
                 else:
                     self.rows = self.rows.dbtable.get_init_list(self.search)
                 return self
-                
+            """        
             self.calc_headers()                                
                     
         elif hasattr(self,'ids'):
@@ -164,15 +155,13 @@ class Table(Unit):
             set_defaults(self,{'delete': delete_table_row, 'append': append_table_row, 'modify': accept_cell_value})   
 
     @property
-    def compact_view(self):
+    def compact_view(self) -> str:
         """only selected are sended to llm"""
-        selected = self.selected_list
-        result = []
+        selected = self.selected_list        
         if not selected and len(self.rows) < max_len_rows4llm:
-            selected = range(len(self.rows))
-        for index in selected:
-            result.append({field: value for field, value in zip(self.headers, self.rows[index])})
-        return {'name': self.name, 'value': result}          
+            selected = range(len(self.rows))        
+        str_rows = ';'.join(','.join(f'{field}: {value}' for field, value in zip(self.headers, self.rows[index])) for index in selected)
+        return f'{self.name} : {str_rows}' 
     
     @property
     def selected_list(self):                            
@@ -180,12 +169,7 @@ class Table(Unit):
 
     def clean_selection(self):        
         self.value = [] if isinstance(self.value,tuple | list) else None
-        return self
-    
-    def extend(self, new_rows):
-        update = self.rows.extend(new_rows)        
-        if hasattr(self,'id'): 
-            dbupdates[self.id].append(update)
+        return self    
     
     def calc_headers(self):        
         """only for persistent"""
@@ -201,15 +185,6 @@ class Table(Unit):
                 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)
     
     async def emit(self, *_):        
         """calcute llm field values for selected rows if they are None"""        
@@ -222,7 +197,7 @@ class Table(Unit):
                         if deps is True:
                             context = values
                         else:
-                            context = {}
+                            context = OrderedDict()
                             for dep in deps:
                                 value = values.get(dep, None)
                                 if value is None:
@@ -236,9 +211,10 @@ class Table(Unit):
                                     else:
                                         raise AttributeError(f'Invalid llm parameter {dep} in {self.name} element!')
                         if context:                                                    
-                            async def assign(index, fld, jcontext):
-                                self.rows[index][self.headers.index(fld)] = await get_property(fld, jcontext)
-                            tasks.append(asyncio.create_task(assign(index, fld, toJson(context))))
+                            async def assign(index, fld, context):
+                                self.rows[index][self.headers.index(fld)] = await get_property(fld, context)                            
+                            context =  ','.join(f'{fld}:{val}' for fld, val in context.items())
+                            tasks.append(asyncio.create_task(assign(index, fld, context)))
             if tasks:
                 await asyncio.gather(*tasks)
                 return self