controller-wisetopdataserver/python/biopro/project/project.py

import sys
import json
import threading

from time import time, sleep
from datetime import datetime
from collections import deque
from copy import copy
from uuid import uuid4

from .task import Task
from .task_manager import TaskManager
from .instruction import Instruction
from biopro.device.manager import DeviceManager
from biopro.text import *

key_list = {
  'deviceList': 'device',
}

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 = 0.1
    self._start_time = None
    self._end_time = None

    self._id = None
    self._uuid = str(uuid4())
    self._name = None
    self._desc = None
    self._device = None
    self._complete_device = []
    self._status = 0

    self._instruction_set = Instruction()
    self._stop_flag  = False

    self._task_manager = None

    self.setup_project(project)
    self.setup_device(self._device)
  
  def setup_project(self, project):
    for (key, value) in project.items():
      if key in key_list.keys():
        key = key_list[key]

      if key == 'task':
        self._task_manager = TaskManager(project['task'])
      elif key == 'uuid':
        pass
      else:
        setattr(self, key, value)
      
  def setup_device(self, device_list):
    for device in device_list:
      complete_device = self._device_manager.get_device(device['connectDevice']['device_address'])
      self._complete_device.append(complete_device)

  @property
  def id(self) -> int:
    return self._id
  
  @id.setter
  def id(self, new_id):
    self._id = new_id
  
  @property
  def uuid(self) -> str:
    return self._uuid
  
  @uuid.setter
  def uuid(self, new_uuid):
    self._uuid = new_uuid

  @property
  def name(self) -> str:
    return self._name
  
  @name.setter
  def name(self, new_name):
    self._name = new_name

  @property
  def desc(self) -> str:
    return self._desc
  
  @desc.setter
  def desc(self, new_desc):
    self._desc = new_desc
  
  @property
  def status(self) -> str:
    return self._status
  
  @status.setter
  def status(self, new_status):
    self._status = new_status

  @property
  def device(self) -> list:
    return self._device
  
  @device.setter
  def device(self, new_device):
    self._device = new_device
  
  @property
  def task_list(self):
    return self._task_manager.export_task_list

  @property
  def mqtt_thread(self):
    return self._mqtt_thread

  @property
  def running_task(self):
    return self._task_manager.running_task

  def run(self):
      self._status = 1
      self._start_time = time()
      self.mqtt_thread.broadcast_command('project:' + self._name + ' start at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
      
      while not self._stop_flag :
        # check running task first
        delay_time = 0
        check_list = copy(self._task_manager.check_list)

        for task in check_list:
          if task != None:
            now = time()
            # print('round task', task.name)
            # print('running task', self._task_manager.running_task.name, self._task_manager.running_task.status)
            # if self._task_manager.prev_task != None:
            #   print('previous_task', self._task_manager.prev_task.name, self._task_manager.prev_task.status)

            match_condition_list = task.check_condition(
              project_start_time = self._start_time,
              delay_time = delay_time,
              running_task= self._task_manager.running_task,
              previous_task =  self._task_manager.prev_task,
              self_task = task
            )
            # print('match_condition_list', match_condition_list)
            for condition in match_condition_list:
              # print('\ncondition.type: ', condition.type)
              match_action_list = task.get_match_action(condition.id)
              # print('match_action_list', match_action_list)
              for action in match_action_list:
                # print('action type', action.type)
                # print('match_action_list len: ', len(match_action_list))
                if action.type == 'start' and task.status != 1:
                  self._task_manager.set_running_task(task)
                  # Trace
                  self.mqtt_thread.broadcast_command('project:task ' + task.name + ' start at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
                elif action.type == 'cycle' and task.status != 1:
                  # TODO: directly goto next without swich cycle as running task
                  """ if task._cycle_count < task._cycle - 1:
                    task._cycle_count += 1
                    cycle_target = self._task_manager.task_list[task._cycle_next - 1] # TODO: not sure deep or shallow
                    cycle_target.reset()
                    task = cycle_target """
                  self._task_manager.set_running_task(task)
                elif action.type == 'stop' and len(self._task_manager.running_task.parameter_set) == 0:
                  self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
                  self._task_manager.running_task.stop()

                elif action.type == 'idle':
                  self._task_manager.running_task.stop()

                device = self._complete_device[action.target]
                task_info = task.get_task_info(action)
                instruction_set = getattr(self._instruction_set, action.type, None)
                # print('instruction_set', instruction_set, '\n', action.type)
                # if instruction_set != None and task.cycle == -1:
                if instruction_set != None and len(task.parameter_set) > 0:
                  for instruction in instruction_set:
                    args = list(map(lambda arg: task_info[arg], instruction['arguments']))
                    threading.Thread(target=getattr(device, instruction['method'])(*args))
            
            delay_time += (time() - now)

        # check task not running then stop
        if self.check_running_task_not_run() == True:
          if self._task_manager.running_task.cycle == -1:
            self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
          self._task_manager.running_task.stop()
          # self._task_manager.set_running_task(task)
        
        # check project done then close project
        if self.check_project_done() == True:
          print('project stop at', datetime.now())
          self.close()
        
        if self._time_interval - delay_time > 0:
          sleep(self._time_interval - delay_time)

  def pause(self):
    # TODO
    pass

  def stop(self):
    self._task_manager.running_task.stop()
    self.mqtt_thread.broadcast_command('project:task ' + str(self._task_manager.running_task.name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])
    self._status = 2
    self._end_time = time()
    self._stop_flag  = True
    self.mqtt_thread.broadcast_command('project:project ' + str(self._name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])

  def close(self):
    self._status = 2
    self._end_time = time()
    self._stop_flag  = True
    self.mqtt_thread.broadcast_command('project:project ' + str(self._name) + ' stop at ' + datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3])

  def check_project_done(self):
    for task in self._task_manager.task_list:
      # if task never start or still task is running then reject 
      if task.status == 1 or task.status == -1:
        return False
    return True
  
  def set_content(self, content):
    self.running_task.button_trigger = True
  
  def check_running_task_not_run(self):
    # if no running task
    if self._task_manager.running_task == None:
      return False
    
    for key in self._task_manager.running_task.action:
      # print('action key', key, self._task_manager.running_task, self._task_manager.running_task.action[key])
      if len(self._task_manager.running_task.parameter_set) == 0 and self._task_manager.running_task.action[key]['type'] == 'stop':
        return False
      if len(self._task_manager.running_task.parameter_set) == 0 and self._task_manager.running_task.action[key]['type'] == 'idle':
        return False
      
    for device in self._task_manager.running_task.device:
      if self._complete_device[device].status == 1:
        return False
    return True
  
  def as_json(self):
    running_task = None
    if self._task_manager.running_task is not None:
      running_task = self._task_manager.running_task.as_json()
    data = {
      'id': self._id,
      'name': self._name,
      'uuid': self._uuid,
      'desc': self._desc,
      'status': self._status,
      'device': self._device,
      'task': self.task_list,
      'running_task': running_task
    }
    return data