[remove] pyc file untracked

python/biopro/api/controller.py

@@ -18,10 +18,9 @@ class ControllerAPI():
     @staticmethod
     def getByMac(mac_address):
         try:
-            if mac_address != None:
-                ret = requests.get(API_URL + 'api/controller/get_by_mac/' + mac_address, headers= AuthAPI.get_key())
-                if ret.status_code == 200:
-                    return ret.json()
+            ret = requests.get(API_URL + 'api/controller/get_by_mac/' + mac_address, headers= AuthAPI.get_key())
+            if ret.status_code == 200:
+                return ret.json()
         except (requests.exceptions.ConnectionError, json.decoder.JSONDecodeError) as e:
             print('get controller fail', e)
         return []

python/biopro/controller.py

@@ -1576,11 +1576,6 @@ class ControlAPI(metaclass=Router):
         should handle this exit code and re-run server process.
         """
         raise NotImplementedError()
-    
-    def run_project(self, project) -> bool:
-        print('create_project', project)
-        self._project_manager.create(project)
-        return False
 
 
 # noinspection PyAbstractClass

python/biopro/device/manager.py

@@ -562,7 +562,6 @@ class DeviceManager(MasterDevice, Synchronized):
 
     @logging_verbose
     def get_device(self, device: Union[int, DeviceInfo]) -> Optional[CompletedDevice]:
-        print('get_device', device)
         """get connected device
 
         :param device: device ID or response info
@@ -575,7 +574,7 @@ class DeviceManager(MasterDevice, Synchronized):
 
         elif isinstance(device, str):
             for slave in self._device:
-                if ':'.join('{:02x}'.format(b) for b in slave.mac_address) == device.lower():
+                if ':'.join('{:02x}'.format(b) for b in slave.mac_address) == device:
                     return slave
 
         elif isinstance(device, DeviceInfo):

python/biopro/devlib/data.py

@@ -882,14 +882,20 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
         if len(data) < 18:
             return None
 
-        time_stamp: float = struct.unpack('<I', data[1:5])[0]  # unit: ms 0x18030000
-        current = struct.unpack('<i', data[5:9])[0]  # unit: nA
-        voltage = struct.unpack('<i', data[9:13])[0]  # unit: uV
-        impedance = struct.unpack('<i', data[13:17])[0]  # unit: mOm
-        cycle_number = struct.unpack('<H', data[17:19])[0]
+        current = struct.unpack('>i', data[1:5])[0]  # unit: 1/1000 nA
+        voltage = struct.unpack('>i', data[5:9])[0]  # unit: mV
+        impedance = struct.unpack('>i', data[9:13])[0]  # unit: kOm
+        time_stamp: float = struct.unpack('<I', data[13:17])[0]  # unit: ms
+        cycle_number = struct.unpack('>H', data[17:19])[0]
         finish_mode_falg = data[19]
 
-        mem_wrong_information = struct.unpack('<i', data[40:40+4])[0] # mem_wrong_information = green retry, green wrong, red retry, red wrong
+        mem_wrong_information = struct.unpack('>i', data[40:40+4])[0]
+
+        # print('decode', list(data[20:]))
+        mem_wrong = data[40]
+        mem_retry_cnt = data[41]
+        mem_green_wrong = data[42]
+        mem_green_retry_cnt = data[43]
         ram_num = data[44]
         broken_flag = data[-1]
 
@@ -911,13 +917,10 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
                 print("error timeStamp full data:", list(data), datetime.now(), '\n')
                 return None
             else:
-                # print('|', time_stamp, '|', delta, '|', int(time_stamp * 1000 / 2),
-                #       '|', current, '|', voltage, '|', impedance,
+                # print('|', time_stamp, '|', delta, '|', current, '|', voltage, '|', impedance,
                 #       '|', cycle_number, '|', finishMode, '@', str(self.device))
-
                 # print('|', '{:10}'.format(time_stamp),
-                #       '|', '{:4}'.format(delta),
-                #       '|', '{:10}'.format(int(time_stamp * 1000 / 2)),
+                #       '|', '{:10}'.format(delta),
                 #       '|', '{:10}'.format(current),
                 #       '|', '{:10}'.format(voltage),
                 #       '|', '{:10}'.format(impedance),
@@ -925,9 +928,13 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
                 #       '|', '{:1}'.format(finishMode),
                 #       '@', str(self.device), '|')
 
-                # print('|', '{:5}'.format(mem_wrong_information),
-                #       '|', '{:2}'.format(ram_num),
-                #       '|', '{:2}'.format(broken_flag),
+                # print('|', '{:5}'.format(mem_wrong),
+                #       '|', '{:5}'.format(mem_retry_cnt),
+                #       '|', '{:5}'.format(mem_green_wrong),
+                #       '|', '{:5}'.format(mem_green_retry_cnt),
+                #       '|', '{:5}'.format(mem_wrong_information),
+                #       '|', '{:5}'.format(ram_num),
+                #       '|', '{:5}'.format(broken_flag),
                 #       '@', str(self.device), '|')
                 pass
 
@@ -944,15 +951,14 @@ class I4V4Z4T4DataDecoder(RecDataDecoder):
         ret.append_data(3, cycle_number)
 
         # memoryboard information
+        # ret.append_data(4, mem_wrong)
+        # ret.append_data(5, mem_retry_cnt)
+        # ret.append_data(6, mem_green_wrong)
+        # ret.append_data(7, mem_green_retry_cnt)
         ret.append_data(4, ram_num)
         ret.append_data(5, broken_flag)
-        try:
-            ret.append_data(6, mem_wrong_information)
-            # print('append_data success, mem_wrong_information:', mem_wrong_information, hex(mem_wrong_information))
-        except:
-            print('append_data fail, mem_wrong_information:', mem_wrong_information, hex(mem_wrong_information))
-
-
+        ret.append_data(6, mem_wrong_information)
+        # ret.append_data(4, ram_num)
     
         if cycle_number != self._cycle_number:
             # notify cycle_number change

python/biopro/devlib/library.py

@@ -1082,11 +1082,6 @@ class CompletedDevice(Device):
         :return: parameter V value
         """
         return self._configuration.get_parameter(name, False)
-    
-    def set_multi_parameters(self, parameter):
-        for (name, value) in parameter[0].items():
-            if name != 'target':
-                self.set_parameter(name, value)
 
     def set_parameter(self, name: str, value: Union[int, str]):
         """replace parameter value with *value*

python/biopro/impl/ext_mem.py

@@ -24,10 +24,8 @@ def zero_buffer(size: int) -> List[int]:
     return [0] * size
 
 class MultiExtMemSpiInterface(LowLevelHardwareInterface):
-    MEM_INS_MARKED1 = [MEM_INS_WRITE, 0, 2, 0x5A, 0xA5]
-    MEM_INS_MARKED2 = [MEM_INS_WRITE, 0, 6, 0x5A, 0xA5]
-    MEM_INS_MARKED3 = [MEM_INS_WRITE, 0, 10, 0x5A, 0xA5]
-    # MEM_INS_RESET  = [MEM_INS_WRITE, 0, 2, 1, 1, 0, 0xFF]
+    MEM_INS_MARKED = [MEM_INS_WRITE, 0, 2, 1, 1]
+    MEM_INS_RESET  = [MEM_INS_WRITE, 0, 2, 1, 1, 0, 0xFF]
 
     __slots__ = ('_selector', '_wait_for_first_data', '_spi', '_tx_buffer_header', '_tx_buffer_data',
                  'pin_busy', 'pin_mem_req', 'pin_mem_sel', 'pin_ram_sel',
@@ -50,7 +48,7 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
         self._single_data_len = self._elite_data_len + self._mem_header_len + self._mem_tailer_len
 
         # buffer
-        self._tx_buffer_header = [0] * 19
+        self._tx_buffer_header = [0] * 11
         self._tx_buffer_data = [0] * (self._single_data_len * 10 + 3)
 
         # memory control pin
@@ -167,29 +165,6 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
         print("read red data times", self._read_red_times)
         return data
 
-    def _print_ram_all_data(self):
-        addr = 0
-        red_length = int(7000 / 2)
-        tx_temp = [0] * red_length
-
-        while True:
-            tx_temp[0] = MEM_INS_READ
-            tx_temp[1] = ((addr >> 8) & 0xFF)
-            tx_temp[2] = (addr & 0xFF)
-
-            ram_data = []
-            ram_data = self._spi.send_byte(tx_temp)
-            ram_data[0:3] = [255, 255, 255]
-            print(list(ram_data), len(ram_data), addr)
-            addr += len(ram_data) - 3
-
-            if (7000 < addr + len(ram_data)):
-                del ram_data
-                break
-        print()
-
-        return
-
     def recv_memory(self, device: int) -> Optional[bytes]:
         self.pin_busy.output(False)
 
@@ -216,7 +191,7 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
                 self._head_wrong_cnt[device] = self._head_wrong_cnt[device] + 1
                 if (self._head_wrong_cnt[device] <= 5): # print 5 times
                     print('data_first[0:3] != [255, 255, 255], device:', device, ',', self._head_wrong_cnt[device], 'times')
-                    print(list(data[0:15]))
+                    print(list(data[0:7]))
 
             data[0:3] = [255, 255, 255]
             # ----------------------------------------------------------------------------------------------
@@ -258,51 +233,29 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
             # green_data = data
             # print("_[Debug] @ spi green data = ", green_data)
 
-            green_data_section1 = data[3:7]
-            green_data_section2 = data[7:11]
-            green_data_section3 = data[11:15]
-
-            if green_data_section1 == green_data_section2:
-                green_data_section = green_data_section1
-
-            elif(green_data_section2 == green_data_section3 or green_data_section1 == green_data_section3):
-                print("green data not equal: = ", data[3:15])
-                print("green data print:", data, device, datetime.now())
-                green_data_section = green_data_section3
-
-            else:
-                print("green data not equal: = ", data[3:15])
-                print("green data print:", data, device, datetime.now())
-                green_data_section = green_data_section3 # use last data
-
-            length = (green_data_section[0] << 8) | green_data_section[1]
-            header = data[15]
-            elite_data_len = data[17]
-
-            if length <= 12:
-                if length < 12:
-                    print("length < 12")
-                    print("green data print:", data, device, datetime.now())
-
-                if length == 0:
-                    self._print_ram_all_data()
+            length = (data[3] << 8) | data[4]
+            header = data[7]
+            elite_data_len = data[9]
 
+            if length <= 4:
+                # print("length <= 4")
+                # print("green data print:", data, device, datetime.now())
                 return None
 
-            if green_data_section[2] != 0xA5 or green_data_section[3] != 0x5A:
+            if data[5] != 0 or data[6] != 0:
                 # give a default length if the data header did not update
+                length = 7000
                 print("green data: is not [0,0], = ", data[5:7])
                 print("green data print:", data, device, datetime.now())
                 return None
 
-            if (length >= 4000):
+            if (length >= 7000):
                 flag_print = True
                 print("green data: big length:", length)
 
             if (header != 255):
                 flag_print = True
                 print("green data: header is not 255: ", header)
-                self._print_ram_all_data()
 
             if (elite_data_len != self._elite_data_len):
                 flag_print = True
@@ -310,7 +263,6 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
 
             if (flag_print):
                 print("green data print:", data, device, datetime.now())
-                print()
 
             # neulive
             # address += len(data) - 11
@@ -322,7 +274,7 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
             # red_length = length - 1 
             # tx_d = [0] * red_length
 
-            address = 12
+            address = 4
             red_length = int(length / 2)
             tx_d = [0] * red_length
 
@@ -367,16 +319,9 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
                     address += len(data) - 3
                     del data
 
-            # last_index = 0
-            # print("_[Debug] @ spi recv data rx, ram_select:", self._pin_ram_sel_value[device], ",", datetime.now())
+            # print("_[Debug] @ spi recv data rx = ")
             # for i in range(0, len(rx), self._single_data_len):
-            #     last_index = i
-            #     # print(rx[i:i+self._single_data_len])
-            #     if i == 0:
-            #         print(rx[0:8], 'ram:', rx[47])
-
-            # if last_index != 0:
-            #     print(rx[last_index:last_index+8], 'ram:', rx[last_index+47])
+            #     print(rx[i:i+self._single_data_len])
             # print()
 
             # /* 
@@ -389,9 +334,7 @@ class MultiExtMemSpiInterface(LowLevelHardwareInterface):
             #  *                                                                  */
 
             # mark read
-            self._spi.send_byte(self.MEM_INS_MARKED1)
-            self._spi.send_byte(self.MEM_INS_MARKED2)
-            self._spi.send_byte(self.MEM_INS_MARKED3)
+            self._spi.send_byte(self.MEM_INS_MARKED)
 
         except BaseException as e:
             print(e)

python/biopro/project/action.py

@@ -1,65 +0,0 @@
-
-class Action():
-    def __init__(self, task, action_id, action):
-        self._task = task
-        self._id:str = action_id
-        self._type:str = action['type']
-        self._target:str = action['target']
-        self._condition_list:list[str] = action['condition']
-        self._duration = action.get('duration', None)
-        self._goto = action.get('goto', None)
-        self._cycle = action.get('cycle', None)
-        
-        self._instruction = None
-
-        self.update_instruction()
-    
-    @property
-    def type(self):
-        return self._type
-
-    def update_instruction(self):
-        self._instruction = {
-            "device_instruction": {
-                "header": "call_instruction",
-                "device": self._target,
-                "arguments": {
-                    "instruction": self._type,
-                }
-            },
-            "device_parameter": {
-                "header": "set_multi_parameters",
-                "device": self._target,
-                "arguments": {
-                    "parameter": self._task.get_parameter_set_by_device(self._target),
-                }
-            },
-            "device_recording_file_name": {
-                "header": "update_recording_file_name_info",
-                "device":  self._target,
-                "arguments": {
-                    "content": self._task.file_name,
-                }
-            },
-            "device_parent": {
-                "header": "update_parent_info",
-                "device":  self._target,
-                "arguments": {
-                    "content": self._task.parent
-                }
-            }
-        }
-
-    def get_condition_list(self):
-        return self._condition_list
-
-    def get_instruction(self, value):
-        return self._instruction[value]
-
-    def get_instruction_list(self):
-        instruction_set = {
-            'start': ['device_parent', 'device_recording_file_name', 'device_parameter', 'device_instruction'],
-            'stop': ['device_instruction'],
-        }
-
-        return map(self.get_instruction, instruction_set[self._type])

python/biopro/project/condition.py

@@ -1,75 +0,0 @@
-from datetime import datetime
-from time import time
-
-class Condition():
-    def __init__(self, id, condition):
-        print('condition', id, condition)
-        self._id = id
-        self._type = condition['type']
-        self._comparsion = condition['comparsion']
-        self._value = condition['value']
-    
-    @property
-    def id(self):
-        return self._id
-    @property
-    def type(self):
-        return self._type
-    @property
-    def comparsion(self):
-        return self._comparsion
-    @property
-    def value(self):
-        return self._value
-    
-    def set_comparsion(self, comparsion):
-        self._comparsion = comparsion
-
-    def set_type(self, type):
-        self._type = type    
-    
-    def set_value(self, value):
-        self._value = value
-
-    def compareWith(self, operator:str, x, y) -> bool:
-        cases = {
-            "equal": lambda a, b: a == b,
-            "bigger": lambda a, b: a > b,
-            "smaller": lambda a, b: a < b,
-        }
-
-        # print('x','y',x, y,type(x),type(y))
-        return cases[operator](x, y)
-
-    def match_or_not(self, **kwargs):
-       return self.method_mapping(self.type)()
-       
-    def absolute_time(self, **kwargs):
-        now = time()
-        time_condition = self.datetime_to_timestamp(self.str_to_datetime(self._value))
-
-        return self.compareWith(self.comparsion, int(now), int(time_condition))
-
-    def relative_time(self, **kwargs):
-        now = time()
-    
-    def device(self, **kwargs):
-        print('device')
-    
-    def task_status(self, **kwargs):
-        print('task_status')
-
-    def method_mapping(self, method_name):
-        methods = {
-        "relative_time": self.relative_time,
-        "absolute_time": self.absolute_time,
-        "device": self.device,
-        "task_status": self.task_status,
-        }
-        return methods[method_name]
-
-    def str_to_datetime(self, time_str):
-        return datetime.strptime(time_str,'%Y-%m-%dT%H:%M')
-
-    def datetime_to_timestamp(self, date):
-        return datetime.timestamp(date)

python/biopro/project/project.py

@@ -1,78 +0,0 @@
-from .task import Task
-from .task_manager import TaskManager
-import sys
-import json
-import threading
-import time
-from datetime import datetime
-from collections import deque
-from biopro.device.manager import DeviceManager
-from biopro.text import *
-
-class Project(threading.Thread):
-  def __init__(self, project, device_manager: DeviceManager, mqttThread = None, name="project"):
-    super(Project, self).__init__(name = name)
-    self._project = project
-    self._device_manager = device_manager
-    self._mqtt_thread = mqttThread
-    self._time_interval = 1
-    self._start_time = None
-
-    self._task_manager = TaskManager(self._project['taskList'])
-
-    self._start_time = None
-    
-  @property
-  def desc(self) -> str:
-    return self._project['desc']
-  
-  @property
-  def status(self) -> str:
-    return self._project['status']
-
-  @property
-  def device(self) -> list:
-    return self._project['deviceList']
-
-  @property
-  def task(self) -> list:
-    return self._task_manager.get()
-
-  @property
-  def get_current_task(self) -> str:
-    return self._task_manager.get_current_task()
-
-  def run(self):
-      self._start_time = time.time()
-
-      while True:
-        # current task
-        for task in self._task_manager.get_check_task_list():
-          # [<match_condition>, ...]
-          match_condition_list = task.check_condition('time')
-          # [[<match_action>, ...], ...]
-          match_action_list = task.get_match_action_list(match_condition_list)
-          
-          for action_list in match_action_list:
-            for action in action_list:
-              if action.type == 'start':
-                self._task_manager.set_current_task(task)
-              task.do_action(action)
-              
-          while len(task.instruction_list) > 0:
-            instruction = task.instruction_list.pop(0)
-            if instruction.get('device', None) != None:
-              device = self._device_manager.get_device(self.device[instruction['device']]['connectDevice']['device_address'])
-
-              if device is None:
-                  raise RuntimeError(DEVICE_NOT_FOUND, device)
-                
-              # print(instruction['header'], *instruction['arguments'].values())
-              getattr(device, instruction['header'])(*instruction['arguments'].values()) 
-
-        time.sleep(self._time_interval)
-  def stop(self):
-    return
-
-  def close(self):
-    return

python/biopro/project/project_manager.py

@@ -1,33 +0,0 @@
-from io import StringIO
-from json import loads as json_parse, dumps as _json_stringify
-from typing import Dict, Optional, Any
-import paho.mqtt.client as mqtt
-from .project import Project
-from biopro.device.manager import DeviceManager
-
-def json_stringify(o: Any) -> str:
-    return _json_stringify(o, separators=(',', ':'))
-
-class ProjectManager():
-    def __init__(self, device_manager: DeviceManager, mqtt_thread=None) :
-        self._project_list = []
-        self._mqtt_thread =  mqtt_thread
-        self._device_manager = device_manager
-    
-    def create(self, project):
-      new_project = Project(project, self._device_manager, self._mqtt_thread)
-      self._project_list.append(new_project)
-      return new_project
-    
-    def remove(self, index):
-      self._project_list[index].stop()
-      del self._project_list[index]
-
-    def get(self):
-      return self._project_list
-
-    def run(self, project):
-      project.start()
-
-    def stop(self, project):
-      project.stop()

python/biopro/project/task.py

@@ -1,168 +0,0 @@
-from .condition import Condition
-from .action import Action
-from time import time
-
-class Task:
-  def __init__(self, task):
-    self._task = task
-
-    self._condition_list = []
-    self._action_list = []
-
-    self._start_time = time()
-    self._idle_time = []
-    self._period = None
-    self._next_time = None
-    self._last_time = None
-
-    self._instruction_list = []
-
-    self.setup()
-  
-  def setup(self) -> None:
-    # add condition
-    for key, condition in self._task['condition'].items():
-      new_condition = Condition(key, condition)
-      self._condition_list.append(new_condition)
-    
-    # add action
-    for key, action in self._task['action'].items():
-      new_action = Action(self, key, action)
-      self._action_list.append(new_action)
-
-  @property
-  def id(self) -> str:
-    return self._task['id']
-  
-  @property
-  def file_name(self):
-    return self._task['name']
-
-  @property
-  def parent(self):
-    return self._task.get('parent', {"folder": [2]})
-
-  @property
-  def instruction_list(self):
-    return self._instruction_list
-
-  @property
-  def cycle(self) -> int:
-    return self._task['cycle']
-
-  @property
-  def order(self) -> int:
-    return self._task['order']
-
-  @property
-  def max_cycle(self) -> int:
-    return self._task['max_cycle']
-  
-  @property
-  def devices(self) -> dict:
-    return self._task['devices']
-
-  @property
-  def devices_id(self) -> list:
-    return [device_id for device_id in self.devices]
-  
-  @property
-  def events(self) -> list:
-    return self._task['events']
-
-  @property
-  def triggers(self) -> list:
-    return self._task['triggers']
-  
-  @property
-  def parameter_set(self) -> list:
-    return self._task['parameterSet']
-  
-  @property
-  def instructions(self) -> list:
-    return self._task['instructions']
-
-  @property
-  def conditions(self) -> list:
-    return self._task['conditions']
-  
-  @property
-  def actions(self) -> list:
-    return self._task['actions']
-
-  @property
-  def condition_list(self) -> list:
-    return self._condition_list
-
-  @property
-  def status(self) -> str:
-    return self._task['status']
-  
-  @property
-  def uuid(self) -> str:
-    return self._task['uuid']
-  
-  @property
-  def next(self) -> str:
-    return self._task['next']
-    
-  def get_parameter_set_by_device(self, device):
-     return [parameter_set for parameter_set in self.parameter_set.values() if device == parameter_set['target']]
-
-  def get_parameter(self, name_or_value, device):
-    name_list = []
-    value_list = []
-    for parameter in self.get_parameter_set_by_device(device):
-      for key, value in parameter.items():
-        if key != 'target':
-          name_list.append(key)
-          value_list.append(str(value))
-
-    return '|'.join(name_list) if name_or_value == 'name' else '|'.join(value_list)
-  
-  def run(self):
-    self._status = 'running'
-    self._start_time = time()
-
-  def pause(self):
-    self._status = 'pause'
-
-  def set_cycle(self, cycle):
-    self._cycle = cycle
-
-  def set_status(self, status):
-    self._status = status
-  
-  def start(self):
-    self.set_status('running')
-  
-  def stop(self):
-    if self.status == 'running':
-      self.do_action('stop')
-    self.set_status('idle')
-
-  def done(self):
-    self.set_status('done')
-  
-  def end(self):
-    self.set_status('end')
-
-  def get_match_action_list(self, match_condition_list):
-    return map(lambda condition: [x for x in self._action_list if condition.id in x.get_condition_list()], match_condition_list)
-
-  def do_action(self, action): 
-    # # match_action = [x for x in self._action_list if condition_id in x.get_condition_list()]
-
-    # for action in match_action:
-    for instruction in action.get_instruction_list():
-      self._instruction_list.append(instruction)
-
-  def status_mapping(self, status):
-    statuses = {
-      "start": self.task_start,
-      "done": self.task_done,
-    }
-    return statuses[status]
-
-  def check_condition(self, type):
-    return [condition for condition in self._condition_list if  condition.match_or_not()]

python/biopro/project/task_manager.py

@@ -1,56 +0,0 @@
-from json import loads as json_parse, dumps as _json_stringify
-from typing import Dict, Optional, Any
-from xml.dom.expatbuilder import parseString
-import paho.mqtt.client as mqtt
-from biopro.text import *
-from .task import Task
-
-_RUNTIME_COMPILE = False
-
-def json_stringify(o: Any) -> str:
-    return _json_stringify(o, separators=(',', ':'))
-
-class TaskManager():
-    def __init__(self, task_list):
-      self._current_task = None
-      self._task_list = []
-      self._need_to_check_task_list = []
-
-      for task in task_list:
-        task = Task(task) 
-        self._task_list.append(task)
-      
-      self.set_current_task(self._task_list[0])
-      self._current_task.run()
-    
-    def remove(self, index):
-      pass
-
-    def get_task(self, task_id):
-      return self._task_list[task_id]
-
-    def get_check_task_list(self):
-      return self._need_to_check_task_list
-
-    def get_current_task(self) -> Task:
-      return self._current_task
-
-    def get_next_task(self):
-      return  self._current_task.next
-
-    def set_current_task(self, task):
-      try:
-        if self._current_task != None and self._current_task.id != task.id:
-          self._current_task.stop()
-
-        self._current_task = task
-        self._need_to_check_task_list = []
-        # append current task
-        self._need_to_check_task_list.append(self._current_task)
-
-        # append next task
-        for task_uuid in self._current_task.next:
-          task = next((task for task in self._task_list if task.uuid == task_uuid), None)
-          self._need_to_check_task_list.append(task)
-      except Exception as e:
-        print(e)