[update] change check time to 1

This reverts commit cd60e14cbe.

python/biopro/recording/file.py

@@ -8,6 +8,7 @@ import gc
 
 from biopro.util.json import JSON
 from biopro.util.stack import print_exception
+from biopro.util.logger import calculate_time
 from .data import RecordingData
 from .loader import *
 
@@ -115,8 +116,8 @@ class RecordingMetaFile(JsonSerialize):
     __slots__ = ('_filename', '_filepath', '_id_db', '_create_time', '_file_version', '_file_uuid', '_data_format', '_last_time',
                  '_device', '_configuration', '_channel_mask', '_database',
                  '_dirty', '_last_modify_time', '_file_size_cache',
-                 '_recording_file_ch', '_size',
-                 '_parameter', '_parent', '_recording_file_name', '_recording_mini_ch',
+                 '_recording_file_ch', '_recording_sub_file', '_size',
+                 '_parameter', '_parent', '_recording_file_name', '_recording_sub_mini', '_recording_mini_ch',
                  '_raw_serial_number', '_mini_serial_number', '_device_id')
 
     def __init__(self, filepath: Union[str, Path], data_format: bytes = None, id_db = 0, database = None):
@@ -167,6 +168,10 @@ class RecordingMetaFile(JsonSerialize):
         self._raw_serial_number = {}
         self._mini_serial_number = {}
 
+        self._recording_sub_file = {}
+        self._recording_sub_mini = {}
+
+
         self._size = 0
 
         self._dirty = True
@@ -304,6 +309,7 @@ class RecordingMetaFile(JsonSerialize):
         if database is not None :
             self._database = database
             self._database.put_queue(['data_meta_write', meta_data, self._device_id, str(self._file_uuid), self._id_db])
+            # database.put_queue(['data_meta_write', self, meta_data, _path, self._id_db])
                 
         with self._filepath.open('wb') as _f:
             f = FileEncoder(_f)
@@ -353,15 +359,58 @@ class RecordingMetaFile(JsonSerialize):
 
     def update_subfile(self, database = None):
         meta_data = {
+            'raw_data': self._recording_sub_file,
+            'mini_data': self._recording_sub_mini,
             'channels': str(self._channel_mask.channels()),
             'size': str(self._size),
             'time_duration': str(self._last_time),
             'uuid': str(self._file_uuid),
         }
+        _path = str(self._filepath).replace('/', '^')
 
         if database is not None :
             self._database = database
             self._database.put_queue(['data_meta_write', meta_data, self._device_id, str(self._file_uuid), self._id_db])
+            # database.put_queue(['data_meta_write', self, meta_data, _path, self._id_db])
+        return None
+    
+    def update_subfile_time_size(self, database = None):
+        meta_data = {
+            'channels': str(self._channel_mask.channels()),
+            'size': str(self._size),
+            'time_duration': str(self._last_time),
+            'uuid': str(self._file_uuid),
+        }
+        _path = str(self._filepath).replace('/', '^')
+
+        if database is not None :
+            self._database = database
+            self._database.put_queue(['data_meta_write', meta_data, self._device_id, str(self._file_uuid), self._id_db])
+            # database.put_queue(['data_meta_write', self, meta_data, _path, self._id_db])
+        return None
+    
+    def update_subfile_raw(self, database = None):
+        meta_data = {
+            'raw_data': self._recording_sub_file,
+        }
+        _path = str(self._filepath).replace('/', '^')
+
+        if database is not None :
+            self._database = database
+            self._database.put_queue(['data_meta_write', meta_data, self._device_id, str(self._file_uuid), self._id_db])
+            # database.put_queue(['data_meta_write', self, meta_data, _path, self._id_db])
+        return None
+    
+    def update_subfile_mini(self, database = None):
+        meta_data = {
+            'mini_data': self._recording_sub_mini,
+        }
+        _path = str(self._filepath).replace('/', '^')
+
+        if database is not None :
+            self._database = database
+            self._database.put_queue(['data_meta_write', meta_data, self._device_id, str(self._file_uuid), self._id_db])
+            # database.put_queue(['data_meta_write', self, meta_data, _path, self._id_db])
         return None
                 
     @property
@@ -965,7 +1014,8 @@ class RecordingFileWriter:
                  '_data_value_ch', '_close', '_data_mini_ch',
                  '_mini_scale_list', '_time_real_time', '_data_rl', '_data_db',
                  '_raw_save', '_mini_save', '_data_time_ch', '_data_value_ch_for_rl',
-                 '_data_time_ch_for_rl', '_device_id', '_send_data', '_data_mqtt_ch', '_id_db_save')
+                 '_data_time_ch_for_rl', '_device_id', '_send_data', '_data_mqtt_ch', '_id_db_save', '_raw_create_not_done',
+                 '_mini_create_not_done')
 
     def __init__(self, meta: RecordingMetaFile, device_id, database = None):
         self._meta = meta
@@ -1046,6 +1096,9 @@ class RecordingFileWriter:
 
         self._splitting_size = None
 
+        self._raw_create_not_done = True
+        self._mini_create_not_done = True
+
 
     @property
     def meta_file(self) -> RecordingMetaFile:
@@ -1066,7 +1119,6 @@ class RecordingFileWriter:
 
     def channels_update(self, channels):
         channels.sort()
-        self._database.put_queue(['data_meta_update_raw_empty_channel', self._meta._id_db, channels])
         self._channel_list.extend(channels)
         return self._channel_list
 
@@ -1080,6 +1132,9 @@ class RecordingFileWriter:
         return None
 
     def close(self):
+        # if self._recording_file is not None:
+        #     self._recording_file.close()
+        #     self._recording_file = None
         print('close1')
         self._close = True
         if len(self._recording_file_dict) > 0:
@@ -1259,7 +1314,8 @@ class RecordingFileWriter:
                     self._data_db[c].append(str(v))
                     self._time_now = int(t)
         return
-
+    
+    @calculate_time(1)
     def write(self, data: Union[bytes, RecordingData, List[bytes], List[RecordingData]], mqtt_thread) -> int:
         # check size
         ths = self.splitting_threshold_size
@@ -1318,18 +1374,34 @@ class RecordingFileWriter:
                 
                 self.get_data_iter(d, mqtt_thread)
 
-            for ch in self._recording_file_dict:
-                if self._recording_file_dict[ch]._id_db == 0:
-                    return None
-
-            data_save = False
-            mini_save = False
             if len(self._recording_file_dict) > 0:
                 for ch in self._data_db.keys():
                     if self._time_now - self._time_real_time[ch] > 1000000:
                         self._send_data[ch] = True
                         self._time_real_time[ch] = self._time_now
-                    if self._time_now - self._time[ch] > 2000000:
+
+            for ch in self._recording_file_dict:
+                if self._recording_file_dict[ch]._id_db == 0:
+                    return None
+            
+            for ch in self._data_db.keys():
+                for scale in self._mini_scale_list:
+                    if  self._recording_mini_dict[str(scale)][ch]._id_db == 0:
+                        return None
+            
+            if self._raw_create_not_done :
+                self._raw_create_not_done = False
+                self._meta.update_subfile_raw(database = self._database)
+            
+            if self._mini_create_not_done :
+                self._mini_create_not_done = False
+                self._meta.update_subfile_mini(database = self._database)
+
+            data_save = False
+            mini_save = False
+            if len(self._recording_file_dict) > 0:
+                for ch in self._data_db.keys():
+                    if self._time_now - self._time[ch] > 5000000:
                         if self._recording_file_dict[ch]._status:
                             _data = ' '.join(self._data_db[ch])
                             write_sz = self._recording_file_dict[ch].write(_data, self._channel_list)
@@ -1345,9 +1417,11 @@ class RecordingFileWriter:
                     if len(self._data_mini_ch[ch]['1000']['mean']) >= 10:
                         mini_save = True
                         for scale in self._mini_scale_list:
+                            str_mean = [str(int) for int in self._data_mini_ch[ch][str(scale)]['mean']]
+                            data_mean = str(self._data_mini_ch[ch][str(scale)]['start_time']) + ' ' + ' '.join(str_mean) + '"***"'
                             self._mini_save[str(scale)]['id'][ch] = self._recording_mini_dict[str(scale)][ch]._id_db
                             self._mini_save[str(scale)]['start_time'][ch] = str(self._data_mini_ch[ch][str(scale)]['start_time'])
-                            self._mini_save[str(scale)]['data_mean'][ch] = self._data_mini_ch[ch][str(scale)]['mean'].copy()
+                            self._mini_save[str(scale)]['data_mean'][ch] = data_mean
                             # self._mini_save[str(scale)]['data_random'][ch] = self._data_mini_ch[ch][str(scale)]['random'].copy()
                             # self._mini_save[str(scale)]['data_bar'][ch] = self._data_mini_ch[ch][str(scale)]['bar'].copy()
                             self._recording_mini_dict[str(scale)][ch].write(self._mini_save[str(scale)]['data_mean'][ch])
@@ -1360,19 +1434,20 @@ class RecordingFileWriter:
                     if self._database is not None:
                         recording_input = ['data_raw_recording_new', copy(self._raw_save['id']), copy(self._channel_list), copy(self._raw_save['data']), copy(self._raw_save['end_time']), copy(self._raw_save['size'])]
                         self._database.put_queue(recording_input)
-                        self._meta.update_subfile(database = self._database)
+                        self._meta.update_subfile_time_size(database = self._database)
                 if mini_save is True:
                     if self._database is not None:
                         for scale in self._mini_scale_list:
-                            self._database.put_queue(['data_mini_recording', self._mini_save[str(scale)]['id'], self._channel_list, self._mini_save[str(scale)]['start_time'], self._mini_save[str(scale)]['data_mean']])
-                        self._meta.update_subfile(database = self._database)
-
+                            self._database.put_queue(['data_mini_recording_new', copy(self._mini_save[str(scale)]['id']), self._channel_list, copy(self._mini_save[str(scale)]['data_mean'])])
+                        self._meta.update_subfile_time_size(database = self._database)
         del data
 
         return None
 
 
     def _switch_recording_file(self):
+        self._raw_create_not_done = True
+
         if len(self._recording_file_dict) > 0:
             for ch in self._recording_file_dict.keys():
                 self._id_db_save[ch] = self._recording_file_dict[ch]._id_db
@@ -1393,13 +1468,14 @@ class RecordingFileWriter:
             self._database.put_queue(['data_raw_create', raw_data_dict, self._channel_list, self._device_id])
 
         self._meta._last_time = self._time_now
-        self._meta.update_subfile(database = self._database)
+        # self._meta.update_subfile(database = self._database)
 
         self._splitting_size = 0
 
         return None
 
     def _switch_recording_mini(self, scale):
+        self._mini_create_not_done = True
         
         if len(self._recording_mini_dict[str(scale)]) > 0:
             for ch in self._recording_mini_dict[str(scale)].keys():
@@ -1419,7 +1495,7 @@ class RecordingFileWriter:
             self._database.put_queue(['data_mini_create', mini_data_dict, self._channel_list, scale, self._device_id])
             
         self._meta._last_time = self._time_now
-        self._meta.update_subfile(database = self._database)
+        # self._meta.update_subfile(database = self._database)
         return None
 
     def update_meta_id(self, _id):
@@ -1428,10 +1504,16 @@ class RecordingFileWriter:
     
     def update_raw_dict_id(self, _channel, _id):
         self._recording_file_dict[int(_channel)]._id_db = _id
-        self._database.put_queue(['data_meta_update_channel_raw_id', self._meta._id_db, _channel, _id])
+        if int(_channel) not in self._meta._recording_sub_file:
+            self._meta._recording_sub_file[int(_channel)] = []
+        self._meta._recording_sub_file[int(_channel)].append(_id)
         return None
 
     def update_mini_dict_id(self, _scale, _channel, _id):
         self._recording_mini_dict[str(_scale)][int(_channel)]._id_db = _id
-        self._database.put_queue(['data_meta_update_channel_mini_id', self._meta._id_db, _channel, _scale, _id])
+        if int(_channel) not in self._meta._recording_sub_mini:
+            self._meta._recording_sub_mini[int(_channel)] = {}
+        if int(_scale) not in self._meta._recording_sub_mini[int(_channel)]:
+            self._meta._recording_sub_mini[int(_channel)][int(_scale)] = []
+        self._meta._recording_sub_mini[int(_channel)][int(_scale)].append(_id)
         return None

python/biopro/server/database.py

@@ -23,6 +23,7 @@ import biopro.server._identify
 from time import time
 
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from biopro.util.logger import calculate_time
 
 _RUNTIME_COMPILE = False
 
@@ -69,6 +70,7 @@ class DataBaseProcess(Process):
         self._data_raw_create_sql_str = None
         self._data_raw_update_sql_str = None
         self._data_raw_recording_sql_str = 'UPDATE "public"."%s_recording_data_raws" SET data = concat(data, %s), end_time=%s, size=%s where id = %s'
+        self._data_mini_recording_sql_str = 'UPDATE "public"."%s_recording_data_minis" SET data_mean = concat(data_mean, %s) where id = %s'
 
     @property
     def db_host(self) -> str:
@@ -85,13 +87,6 @@ class DataBaseProcess(Process):
     @property
     def api_token(self) -> str:
         return self._api_token
-    
-    def calculate_time(func):
-        def warp(*args, **kwargs):
-            now = time()
-            func(*args, **kwargs)
-            print(func.__name__,'cost:', time() - now)
-        return warp
 
     def run(self) -> None:
         self.setup()
@@ -165,7 +160,7 @@ class DataBaseProcess(Process):
             getattr(self, do)(*args)
         return None
 
-    # @calculate_time
+    @calculate_time(1)
     def data_meta_write(self, _data: JSON_OBJECT, device_id, _uuid = None, _id = None):
         if _id > 0:
             sql_str = 'UPDATE "public"."recording_data_metas" SET '
@@ -268,6 +263,7 @@ class DataBaseProcess(Process):
         # _conn.close()
         return None
 
+    # @calculate_time()
     def data_meta_get(self, _path = None, _id = None):
         if _id is not None:
             sql_str = 'SELECT * FROM "public"."recording_data_metas" WHERE id = %s'
@@ -302,6 +298,7 @@ class DataBaseProcess(Process):
         # _conn.close()
         return None
 
+    # @calculate_time()
     def data_meta_id_get_by_path(self, _path = None):
         ret = None
         if _path is not None:
@@ -323,7 +320,7 @@ class DataBaseProcess(Process):
         # _conn.close()
         return None
 
-    # @calculate_time
+    # @calculate_time()
     def data_raw_create(self, _data_dict, _channel_list, device_id):
         if self._data_raw_create_sql_str == None:
             sql_str_list = []
@@ -345,7 +342,7 @@ class DataBaseProcess(Process):
 
         return True
 
-    # @calculate_time
+    # @calculate_time()
     def data_raw_update(self, _id, _channel, _data: JSON_OBJECT):
         sql_str = 'UPDATE "public"."' + str(_channel) + '_recording_data_raws" SET '
         sql_set = []
@@ -365,7 +362,7 @@ class DataBaseProcess(Process):
         sql_cursor.close()
         return None
 
-    # @calculate_time
+    # @calculate_time()
     def data_raw_recording(self, _id_dict, _channel_list, _data_dict, _id_db_save):
         try:
             with self._psql_conn as conn:
@@ -379,19 +376,20 @@ class DataBaseProcess(Process):
             print('recording error', e)
         return None
     
-    # @calculate_time
+    @calculate_time(1)
     def data_raw_recording_new(self, _id_dict, _channel_list, _data_dict, _end_time_dict, _size_dict):
         try:
+            para_list = []
+            for _channel in _channel_list:
+                para_list.append([_channel, _data_dict[_channel] + '"***"', _end_time_dict[_channel], _size_dict[_channel], _id_dict[_channel]])
             with self._psql_conn as conn:
                 with conn.cursor() as sql_cursor:
-                    para_list = []
-                    for _channel in _channel_list:
-                        para_list.append([_channel, _data_dict[_channel] + '"***"', _end_time_dict[_channel], _size_dict[_channel], _id_dict[_channel]])
                     execute_batch(sql_cursor, self._data_raw_recording_sql_str, para_list)
         except psycopg2.Error as e:
             print('recording error', e)
         return None
-
+    
+    # @calculate_time()
     def data_mini_create(self, _data_dict, _channel_list, _scale, device_id):
         for _channel in _channel_list:
             sql_str = 'INSERT INTO "public"."' + str(_channel) + '_recording_data_minis" ('
@@ -425,6 +423,7 @@ class DataBaseProcess(Process):
         # _conn.close()
         return True
 
+    # @calculate_time()
     def data_mini_recording(self, _id_dict, _channel_list, _start_time_dict, _data_mean_dict):
         with self._psql_conn as conn:
             with self._psql_conn.cursor() as sql_cursor:
@@ -444,9 +443,23 @@ class DataBaseProcess(Process):
         for _channel in _channel_list:
             del _start_time_dict[_channel], _data_mean_dict[_channel]
         gc.collect()
-        
+
         return True
     
+    @calculate_time(1)
+    def data_mini_recording_new(self, _id_dict, _channel_list, _data_mean_dict):
+        try:
+            para_list = []
+            for _channel in _channel_list:
+                para_list.append([_channel, _data_mean_dict[_channel], _id_dict[_channel]])
+            with self._psql_conn as conn:
+                with conn.cursor() as sql_cursor:
+                    execute_batch(sql_cursor, self._data_mini_recording_sql_str, para_list)
+        except psycopg2.Error as e:
+            print('recording error', e)
+        return None
+
+    # @calculate_time()
     def data_mini_update(self, _id, _channel, _data: JSON_OBJECT):
         sql_str = 'UPDATE "public"."' + str(_channel) + '_recording_data_minis" SET '
         sql_set = []
@@ -481,26 +494,58 @@ class DataBaseProcess(Process):
             print('e', e)
 
         return True
-
+    
+    # @calculate_time()
     def data_meta_update_channel_raw_id(self, meta_id, channel, raw_id):
         try:
+            with self._psql_conn as conn:
+                with conn.cursor() as sql_cursor:
+                    sql_str = "UPDATE recording_data_metas SET raw_data = jsonb_insert(raw_data, '{%s, -1}', '%s', TRUE) WHERE id = %s;"
+                    sql_set = [channel, raw_id, 571]
+                    sql_cursor.execute(sql_str, sql_set)
+        except psycopg2.Error as e:
+            print('e', e)
+
+        return True
+
+    # @calculate_time()
+    def data_meta_update_all_channel_raw_id(self, meta_id:str, raw_id_dict:dict):
+        try:
+            sql_str = "UPDATE recording_data_metas SET raw_data = jsonb_insert(raw_data, '{%s, -1}', '%s', TRUE) WHERE id = %s;"
+            sql_set = []
+            for ch in raw_id_dict.keys():
+                sql_set.append([ch, raw_id_dict[ch], meta_id])
             with self._psql_conn as conn:
                     with conn.cursor() as sql_cursor:
-                        sql_str = "UPDATE recording_data_metas SET raw_data = jsonb_insert(raw_data, '{%s, -1}', '%s', TRUE) WHERE id = %s;"
-                        sql_set = [channel, raw_id, meta_id]
+                        execute_batch(sql_cursor, sql_str, sql_set)
+        except psycopg2.Error as e:
+            print('e', e)
+
+        return True
+    
+    def data_meta_update_channel_mini_id(self, meta_id, channel, scale, mini_id):
+        try:
+            with self._psql_conn as conn:
+                    with conn.cursor() as sql_cursor:
+                        sql_str = "UPDATE recording_data_metas SET mini_data = jsonb_insert(mini_data, '{%s, %s, -1}', '%s', TRUE) WHERE id = %s;"
+                        sql_set = [channel, scale, mini_id, meta_id]
                         sql_cursor.execute(sql_str, sql_set)
         except psycopg2.Error as e:
             print('e', e)
 
         return True
     
-    def data_meta_update_channel_mini_id(self, meta_id, channel, scale, raw_id):
+    # @calculate_time()
+    def data_meta_update_all_channel_mini_id(self, meta_id, mini_id_dict):
         try:
+            sql_str = "UPDATE recording_data_metas SET mini_data = jsonb_insert(mini_data, '{%s, %s, -1}', '%s', TRUE) WHERE id = %s;"
+            sql_set = []
+            for ch in mini_id_dict.keys():
+                for scale in mini_id_dict[ch].keys():
+                    sql_set.append([ch, scale, mini_id_dict[ch][scale], meta_id])
             with self._psql_conn as conn:
-                    with conn.cursor() as sql_cursor:
-                        sql_str = "UPDATE recording_data_metas SET mini_data = jsonb_insert(mini_data, '{%s, %s, -1}', '%s', TRUE) WHERE id = %s;"
-                        sql_set = [channel, scale, raw_id, meta_id]
-                        sql_cursor.execute(sql_str, sql_set)
+                with conn.cursor() as sql_cursor:
+                    execute_batch(sql_cursor, sql_str, sql_set)
         except psycopg2.Error as e:
             print('e', e)
 

python/biopro/server/recording.py

@@ -160,7 +160,11 @@ class RecordingProcess(Process):
         """
         q = None
         try:
+            now = time()
             q = self._queue_rec.get()
+            get_queue_time_cost = time() - now
+            if get_queue_time_cost > 1:
+                print('get queue cost time', get_queue_time_cost)
         except:
             return False
         finally:

python/biopro/util/logger.py

@@ -3,6 +3,7 @@ import inspect
 import os
 import sys
 import threading as _threading
+from time import time
 from datetime import datetime
 from functools import wraps
 from typing import Any, Optional, Tuple, Union
@@ -520,3 +521,17 @@ def logging_error(f):
         return f(self, *args, **kwargs)
 
     return _logger
+
+    
+def calculate_time(time_limit=None):
+    def actual_calculate_time(func):
+        def warp(*args, **kwargs):
+            now = time()
+            func(*args, **kwargs)
+            if time_limit == None:
+                print(func.__name__,'cost:', time() - now)
+            else:
+                if time() - now > time_limit:
+                    print(func.__name__,'cost:', time() - now)
+        return warp
+    return actual_calculate_time