def send_wait_serial(data): app.logger.info(f'Sending {data} to PLC') if app.use_flask_serial: plc_ser.on_send(data + '\r\n') else: plc_ser.send_data(data) socketio.start_background_task(wait_for_start)
def on_background_start(self, data): _id = session['socket_id'] try: if running_process[_id] is False: running_process[_id] = True socketio.start_background_task(background_thread, _id, data) except KeyError: running_process[_id] = True socketio.start_background_task(background_thread, _id, data) emit('connection_response', { 'data': 'Connected', 'id': session['socket_id'] })
def create_game(self, game_id, score_max_distance, max_response_time, leaderboard_answer_count, between_turns_duration): app.logger.debug('Starting a new game with the id {game_id}'.format(game_id=game_id)) # Create the game game = Game(game_id, score_max_distance, max_response_time, leaderboard_answer_count, between_turns_duration) # Register it self.games.append(game) # Start the game socketio.start_background_task(target=self.run_game, game=game) return game
def create_game(self, game_id, score_max_distance, max_response_time, leaderboard_answer_count, between_turns_duration): app.logger.debug('Starting a new game with the id {game_id}'.format(game_id=game_id)) # Create the game game = Game(game_id, score_max_distance, max_response_time, leaderboard_answer_count, between_turns_duration) # Register it self.games.append(game) # Start the game socketio.start_background_task(target=self.run_game, game=game) return game
def test_connect(): app.data.console_queue.put("connected") app.data.console_queue.put(request.sid) if app.uithread == None: app.uithread = socketio.start_background_task( app.UIProcessor.start, current_app._get_current_object()) app.uithread.start() if not app.data.connectionStatus: app.data.console_queue.put( "Attempting to re-establish connection to controller") app.data.serialPort.openConnection() socketio.emit("my response", {"data": "Connected", "count": 0}) address = app.data.hostAddress data = json.dumps({"hostAddress": address}) print(data) socketio.emit( "message", { "command": "hostAddress", "data": data, "dataFormat": "json" }, namespace="/MaslowCNC", ) if app.data.pyInstallUpdateAvailable: app.data.ui_queue1.put("Action", "pyinstallUpdate", "on")
def reload_status(): ecoe_configs = Manager.get_ecoe_config_files() for ecoe_config in ecoe_configs: # 1. Create configuration in app memory ecoe = Manager.create_config(ecoe_config) # 2. Load objects for e_round in ecoe.rounds: try: round_status = Manager.load_status_from_file( e_round.status_filename) if len(round_status) > 0: chrono_status = Manager.load_status_from_file( e_round.chrono.status_filename) if len(chrono_status) > 0: e_round.chrono.minutes = chrono_status['minutes'] e_round.chrono.seconds = chrono_status['seconds'] e_round.chrono.state = chrono_status['state'] ecoe.threads.append( socketio.start_background_task( target=e_round.start, state=round_status['state'], current_rerun=round_status['current_rerun'], idx_schedule=round_status[ 'current_idx_schedule'])) except: pass
def on_connect(self): global thread with thread_lock: if thread is None: thread = socketio.start_background_task( target=background_thread) emit('my_response', {'data': 'Connected', 'count': 0})
def test_connect(): global thread print('Client connected') if not thread.isAlive(): thread_stop_event.clear() print("Starting Thread") thread = socketio.start_background_task(sendValues)
def start(self): """ start to listen to the serial port of the Arduino """ # opening the serial if not self.is_open(): s = self.open_serial() # configure the serial if self.setpoint: self.set_setpoint() time.sleep(0.2) if self.gain: self.set_gain() time.sleep(0.2) if self.integral: self.set_integral() time.sleep(0.2) if self.diff: self.set_differential() # starting the listener if not self.is_alive(): self.switch = True db.session.commit() thread = socketio.start_background_task(target=do_work, id=self.id) self.thread_id = thread.ident db.session.commit() workers.append(thread) else: print('Already running')
def start(self): """ start to listen to the serial port of the Arduino """ # test if everything is open if not self.is_open(): print('No connection'); return # configure the arduino if self.setpoint: self.set_setpoint(); time.sleep(0.2); if self.gain: self.set_gain(); time.sleep(0.2); if self.integral: self.set_integral(); time.sleep(0.2); if self.diff: self.set_differential(); # starting the listener if not self.is_alive(): self.switch = True db.session.commit(); thread = socketio.start_background_task(target=do_web_work, id = self.id, app = current_app._get_current_object()); self.thread_str = str(thread.ident) db.session.commit() workers.append(thread); else: print('Already running')
def tool_connect(): print('Client connected') global thread with thread_lock: if thread is None: thread = socketio.start_background_task(target=background_thread) emit("server_log", {'data': 'Connect'})
def solver(): global current_question, current_game, timeout current_question = 0 if "timer" in current_game: timeout = int(current_game["timer"]["timeout"]) if( timeout >= 0): socketio.start_background_task(target=timer) try: import RPi.GPIO as GPIO GPIO.setmode(GPIO.BCM) except: response = "There was an error setting up GPIO." logging.error(response) logger.info("""Current game is: "{0}" """.format(current_game)) current_qa = current_game['questions'][current_question] logger.info("""Current question is: "{0}" """.format(current_qa['question'])) logger.info("""Current right answer is: "{0}" """.format(current_qa['answer'])) #logger.info("timer started") #socketio.sleep(5) #logger.info("timer expired") #socketio.emit('next question', current_question +1, namespace='/test') #return questions_n = len(current_game['questions']) for n in range(0, questions_n): pin = current_qa['answer'][n] GPIO.setup(int(pin), GPIO.IN) while game_in_progress: if GPIO.input(int(pin)) == True: logger.info("Detected the correct pin.") current_question = current_question + 1 socketio.emit('next question', current_question, namespace='/test') break else: logger.info("Detected the wrong pin.") current_question = 0 socketio.emit('lost', current_question, namespace='/test') return socketio.emit('win', current_question, namespace='/test') return
def registerPatientEvent(message): registrationToken = message["registrationToken"] windowToken = message["windowToken"] global thread with thread_lock: #if thread is None: thread = socketio.start_background_task(background_thread, registrationToken, windowToken)
def test_connect(): global thread #TODO change the idea of sending the user's name name = tg_module.dia[-1].obj.name socketio.emit('info_responder', {'self_name': name}, namespace='/main') with locky: if thread is None: thread = socketio.start_background_task(target=tg_module.resender)
def on_connect(self): global thread with thread_lock: if thread is None: thread = socketio.start_background_task(active911_thread, \ current_app._get_current_object()) emit('my_response', {'data': 'Connected', 'count': 0})
def test_connect(message): global thread with thread_lock: if thread is None: thread = socketio.start_background_task( target = background_thread) emit('my_request', {'data': 'Connected', 'sid':request.sid})
def pilab_connect(): ''' Start the background thread upon connecting ''' global thread with thread_lock: if thread is None: thread = socketio.start_background_task(target=background_thread)
def test_connect(): global thread with thread_lock: if thread is None: thread = socketio.start_background_task(target=get_messages) emit('my_response', {'data': 'Connected', 'count': 0}) print('connected')
def start_job_manager() -> None: """ Starts the main job manager thread for the backend system. :return: """ job_thread = socketio.start_background_task(target=_spawn_jobqueue) # type: Thread job_thread.start()
def test_connect(): print("----Client Connected------") global thread ms = {"Message": "Connected to server"} with thread_lock: if thread is None: thread = socketio.start_background_task(task_scheduler) emit('get_tasks_response', {"data": json.dumps(ms)})
def on_connect(self): from app import socketio global thread emit("connected", "connected") socketio.sleep(5) if thread is None: with current_app.app_context(): thread = socketio.start_background_task( background_thread, socketio, request.sid)
def test_connect(): # 单例模式创建线程,定时发布消息 global thread1, thread2 with lock: if thread1 is None: thread1 = socketio.start_background_task(target=background_task) thread2 = socketio.start_background_task(target=background_task2) # 未读信息 if isinstance(current_user.is_anonymous, bool): return else: # 私信未读 message = Message.query.filter_by(toId=current_user.id, hasRead=0).all() # feed # h = a-b if a>b else a+b emit('noreadmsg', {'data': '' if len(message) == 0 else len(message)})
def start_background(target, secs, resp_id): socket_thread = socketio.start_background_task( target=target, socketio=socketio, secs=secs, resp_id=resp_id ) return socket_thread
def add_samples_by_csv(): if request.method == 'OPTIONS': return jsonify({'status': 'Success'}) @copy_current_request_context def bg_add_samples_by_csv(sample_file, project_id): task = 'add_samples' task_notifier = TaskNotifier(task=task, namespace=SOCK_NAMESPACE) task_notifier.emit_task_start() project = GenotypingProject.query.get(project_id) if not project: task_notifier.emit_task_failure(message="Genotyping Project Not Found. Restart Application.") sample_ids = [] try: task_notifier.emit_task_progress(progress={ 'style': 'indeterminate', 'total': 1, 'current_state': 1, 'message': 'Adding Samples...' }) r = CaseInsensitiveDictReader(sample_file) for line in r: barcode = line['sample_id'] sample = Sample.query.filter(Sample.barcode == barcode).first() if not sample: task_notifier.emit_task_failure(message=f"Sample with barcode '{barcode}' does not exist.") return sample_ids.append(sample.id) project.add_samples(sample_ids) except KeyError: task_notifier.emit_task_failure(message=f"File Malformed. Header must be 'Sample ID'") project.last_updated = datetime.utcnow() task_notifier.emit_task_success(message="Successfully Added Samples.") sample_file = request.files.getlist('files')[0] sample_file_stream = io.StringIO(sample_file.stream.read().decode("utf-8"), newline=None) project_id = request.form.get('project_id') socketio.start_background_task(bg_add_samples_by_csv, sample_file_stream, project_id) return jsonify({'status': 'Success'})
def log_connect(): app.data.console_queue.put("connected to log") app.data.console_queue.put(request.sid) if app.logstreamerthread == None: app.logstreamerthread = socketio.start_background_task( app.LogStreamer.start, current_app._get_current_object() ) app.logstreamerthread.start() socketio.emit("my response", {"data": "Connected", "count": 0}, namespace="/MaslowCNCLog")
def test_connect(): print("connected") print(request.sid) if app.uithread == None: app.uithread = socketio.start_background_task( app.UIProcessor.start, current_app._get_current_object() ) app.uithread.start() socketio.emit("my response", {"data": "Connected", "count": 0})
def test_connect(): time_dict() global thread if thread is None: # Once any client is connected, the background_thread function starts in loop thread = socketio.start_background_task(target=background_thread) socketio.emit('my_response', {'data': 'Message from server', 'time': time}, namespace='/test')
def unload(): print('close') sid = int(request.headers['Referer'].split('_')[2]) cid = current_user.id room = get_room(sid, cid) out_room(room, sid, cid) # save massage to file global thread with thread_lock: if thread is None: thread = socketio.start_background_task(msg_to_file, room)
def watchdog_connect(): app.data.console_queue.put("watchdog connected") app.data.console_queue.put(request.sid) socketio.emit("connect", namespace="/WebMCP") if app.mcpthread == None: app.data.console_queue.put("going to start mcp thread") app.mcpthread = socketio.start_background_task( app.data.mcpProcessor.start, current_app._get_current_object()) app.data.console_queue.put("created mcp thread") app.mcpthread.start() app.data.console_queue.put("started mcp thread")
def test_connect(message): """ 使用线程,后台异步执行推送 :param message: :return: """ global thread with thread_lock: if thread is None: thread = socketio.start_background_task(target=background_thread) emit('my_request', {'data': 'Connected', 'sid': request.sid})
def test_connect(): global thread if thread is None: thread = socketio.start_background_task(target=background_thread) for c in current_user.chats: join_room(str(c.chat.id)) string=readLog(str(c.chat.id)) for s in string[1:-1]: mess = split("\t", s) #if mess[2] is not None: emit('my_response', {'data': mess[2], 'user': mess[0], 'room': str(c.chat.id), 'date':mess[1]})
def client_connect(): global camera_streams_thread global display_thread host = current_app.config['FTP_HOST'] user = current_app.config['FTP_USER'] password = current_app.config['FTP_PASSWORD'] with thread_lock: if display_thread is None: ftp_client = FtpClient(host, user, password) display_thread = socketio.start_background_task( display_images, current_app._get_current_object(), ftp_client) if camera_streams_thread is None: ftp_client = FtpClient(host, user, password) image_downloader = ImageDownloader() camera_streams_thread = socketio.start_background_task( camera_streams, current_app._get_current_object(), ftp_client, image_downloader) emit('server_event', {'data': 'Client connected', 'count': 0})
def connect(): """new client connected""" if current_app.config['child_pid']: # already started child process, don't start another return # create child process attached to a pty we can read from and write to (child_pid, fd) = pty.fork() if child_pid == 0: # this is the child process fork. # anything printed here will show up in the pty, including the output # of this subprocess print('Using pid %i ...' % os.getpid()) print('Starting subcommand %s ...' % current_app.config['CMD']) sys.stdout.flush() subprocess.run(current_app.config['CMD']) print('Exit the child!') sys.stdout.flush() #sys.exit(0) os._exit(0) # quit the child process leaves the process as zombie ... else: # this is the parent process fork. # store child fd and pid msg = 'Create a child process pid={}'.format(child_pid) current_app.logger.info(msg) # copy the data to the app context current_app.config['fd'] = fd current_app.config['child_pid'] = child_pid set_winsize(fd, 50, 50) #cmd = " ".join(shlex.quote(c) for c in current_app.config["cmd"]) cmd = current_app.config['CMD'] #print('child pid is', child_pid) #print( # f'starting background task with command `{cmd}` to continously read ' # 'and forward pty output to client' #) socketio.start_background_task(target=read_and_forward_pty_output, app=current_app._get_current_object())
def start(self): """ start to listen to the serial port of the Arduino """ print('Starting the listener.') if not self.switch: self.switch = True db.session.commit(); thread = socketio.start_background_task(target=do_work, cam_id = self.id); self.thread_id = thread.ident; db.session.commit() workers.append(thread); else: print('Already running')
def upload_samples(): if request.method == 'OPTIONS': return jsonify({'status': 'Success'}) @copy_current_request_context def bg_upload_samples(sample_file): task = 'upload_samples' task_notifier = TaskNotifier(task=task, namespace=SOCK_NAMESPACE) task_notifier.emit_task_start() with open(sample_file, 'r') as f: try: r = CaseInsensitiveDictReader(f) entries = list(r) id_field = next(_ for _ in ['barcode', 'sample_id', 'id'] if _ in r.fieldnames) designation_field = next(_ for _ in ['designation'] if _ in r.fieldnames) task_notifier.emit_task_progress(progress={ 'style': 'determinate', 'total': len(entries), 'current_state': 1, 'message': 'Creating Samples...' }) for idx, entry in enumerate(entries): barcode = entry[id_field].strip() designation = entry.get(designation_field, 'sample').strip() if barcode: sample = Sample(barcode=barcode, designation=designation) db.session.add(sample) task_notifier.emit_task_progress(progress={ 'style': 'determinate', 'total': len(entries), 'current_state': idx + 1, 'message': 'Creating Samples...' }) except UnicodeDecodeError: task_notifier.emit_task_failure( message="Sample File Malformed. Must be CSV File." ) db.session.rollback() return except StopIteration: task_notifier.emit_task_failure( message="Sample File Malformed. Sample Identifier Must be [('Barcode', 'Sample ID', or 'ID'), " "'Designation']. " ) db.session.rollback() return except (sqlite3.IntegrityError, sqlalchemy.exc.IntegrityError): task_notifier.emit_task_failure(message=f'{id_field} Must Be Unique.') db.session.rollback() return except AssertionError: task_notifier.emit_task_failure( message="Sample File Malformed. Designation must be one of ['Negative Control', 'Positive " "Control', 'Sample'] " ) except Exception as e: # print(e) task_notifier.emit_task_failure( message="Something Bad Happened Creating Samples... Restart App" ) return task_notifier.emit_task_success() sample_file = request.files.getlist('files')[0] handle, tmpfile_path = tempfile.mkstemp() tmpfile = os.fdopen(handle, mode='wb') tmpfile.write(sample_file.stream.read()) socketio.start_background_task(bg_upload_samples, tmpfile_path) return jsonify({'status': 'Success'})
def add_controls_by_csv(): if request.method == 'OPTIONS': return jsonify({'status': 'Success'}) @copy_current_request_context def bg_add_controls_by_csv(control_file, project_id): task = 'add_controls' task_notifier = TaskNotifier(task=task, namespace=SOCK_NAMESPACE) task_notifier.emit_task_start() project = QuantificationBiasEstimatorProject.query.get(project_id) if not project: task_notifier.emit_task_failure( message="Quantification Bias Estimator Project Not Found. Restart Application." ) return task_notifier.emit_task_progress(progress={ 'style': 'indeterminate', 'total': 1, 'current_state': 1, 'message': 'Associating Controls...' }) r = CaseInsensitiveDictReader(control_file) control_map = {} for d in r: try: barcode = d.pop('barcode') except KeyError: task_notifier.emit_task_failure(message="CSV file malformed. Barcode column not found.") return if not barcode: task_notifier.emit_task_failure(message='CSV file malformed. Barcode field empty') return sample_id = Sample.query.filter(Sample.barcode == barcode).value(Sample.id) if not sample_id: task_notifier.emit_task_failure(message=f'Sample with barcode {barcode} does not exist.') return sample_already_present = db.session.query( ControlSampleAssociation.query .join(ProjectSampleAnnotations) .filter(ProjectSampleAnnotations.project_id == project_id, ProjectSampleAnnotations.sample_id == sample_id) .exists() ).scalar() if sample_already_present: task_notifier.emit_task_failure(message=f'Sample with barcode {barcode} already in project') return controls_and_props = d.values() controls_and_props = list(map(lambda _: _.strip().split(';'), controls_and_props)) controls = [] for control_and_prop in controls_and_props: if len(control_and_prop) > 1: control, prop = control_and_prop try: prop = float(prop) except ValueError: task_notifier.emit_task_failure( message=f"Failed to associate controls. {control} proportion field malformed." ) return try: c = Control.query.filter(Control.barcode == control).filter( Control.bin_estimator_id == project.bin_estimator_id).one() except NoResultFound: task_notifier.emit_task_failure( message=f"Failed to find control {control}. " f"Make sure it exists for associated Bin Estimator." ) return controls.append((c.id, prop)) if controls: control_map[sample_id] = controls sample_ids = control_map.keys() project.add_samples(sample_ids) # db.session.flush() sample_annotation_ids = project.sample_annotations.values( ProjectSampleAnnotations.id, ProjectSampleAnnotations.sample_id ) for sa_id, sample_id in sample_annotation_ids: if sample_id in control_map: try: project.assign_controls(sa_id, control_map[sample_id]) except BadProportions: db.session.rollback() task_notifier.emit_task_failure(message="Control proportions do not sum to 1") return task_notifier.emit_task_success(message="Successfully Added Samples.") control_file = request.files.getlist('files')[0] control_file_stream = io.StringIO(control_file.stream.read().decode('utf-8'), newline=None) project_id = request.form.get('project_id') socketio.start_background_task(bg_add_controls_by_csv, control_file_stream, project_id) return jsonify({'status': 'Success'})
def upload_plate_map(): @copy_current_request_context def bg_upload_plate_map(plate_map_file, plate_id, create_non_existent_samples): socketio.sleep() task = 'upload_plate_map' task_notifier = TaskNotifier(task=task, namespace=SOCK_NAMESPACE, plate_id=plate_id) task_notifier.emit_task_start() plate = Plate.query.get(plate_id) if not plate: task_notifier.emit_task_failure(message="No Plate Map Uploaded") else: plate_map = csv.DictReader(plate_map_file) if 'well' not in [_.lower() for _ in plate_map.fieldnames]: task_notifier.emit_task_failure(message="Plate Map Malformed.") return locus_labels = [_.strip() for _ in plate_map.fieldnames if _.lower() not in ['', 'well']] clear_plate_map(plate_id) stale_tracker = dict() plate_map = list(plate_map) total_steps = len(plate_map) for idx, entry in enumerate(plate_map): socketio.sleep() well_label = entry['Well'].strip() for locus_label in locus_labels: socketio.sleep() sample_barcode = entry[locus_label].strip() if sample_barcode: sample = Sample.query.filter(Sample.barcode == sample_barcode).one_or_none() locus = Locus.query.filter(Locus.label == locus_label).one_or_none() if not sample and create_non_existent_samples: sample = Sample(barcode=sample_barcode, designation='sample') db.session.add(sample) if not sample: task_notifier.emit_task_failure( message=f"Sample with barcode '{sample_barcode}' does not exist." ) db.session.rollback() return if not locus: task_notifier.emit_task_failure( message=f"Locus with label '{locus_label}' does not exist." ) db.session.rollback() return projects = get_projects_with_samples(sample.id, locus.id) well = plate.wells_dict[well_label] channel = well.channels_dict[locus.color] channel.add_locus(locus.id) channel.add_sample(sample.id) for project in projects: if not channel_in_project(project.id, channel.id): project.add_channel(channel.id) if not (project.id, locus.id,) in stale_tracker: lp = ProjectLocusParams.query.filter( ProjectLocusParams.project_id == project.id ).filter( ProjectLocusParams.locus_id == locus.id ).one() lp.scanning_parameters_stale = True stale_tracker[(project.id, locus.id)] = True task_notifier.emit_task_progress( progress={ 'style': 'determinate', 'total': total_steps, 'current_state': idx + 1, 'message': f'Processing {sample_barcode} at {locus_label}...' } ) task_notifier.emit_task_success(message="Plate Map Loaded Successfully") plate_map_file = request.files.getlist('files')[0] plate_map_stream = io.StringIO(plate_map_file.stream.read().decode("utf-8"), newline=None) create_non_existent_samples = request.form.get('create_non_existent_samples') == 'true' plate_id = int(request.form.get('plate_id')) socketio.start_background_task(bg_upload_plate_map, plate_map_stream, plate_id, create_non_existent_samples) return jsonify({'status': "Success"})
def upload_plates(): if request.method == 'OPTIONS': return jsonify({'status': 'Success'}) @copy_current_request_context def bg_upload_plates(plate_files, ladder_id): extracted_plates = [] ladder = Ladder.query.get(ladder_id) task = 'upload_plate' task_notifier = TaskNotifier(task=task, namespace=SOCK_NAMESPACE, ladder_id=ladder_id) task_notifier.emit_task_start() for idx, plate_zip_file in enumerate(plate_files): try: with open(plate_zip_file, 'rb') as plate_zip: extracted_plate = ExtractedPlate.from_zip_and_calculate_base_sizes( zip_file=plate_zip, ladder=ladder.base_sizes, color=ladder.color, base_size_precision=ladder.base_size_precision, sq_limit=ladder.sq_limit, filter_parameters=ladder.filter_parameters, scanning_parameters=ladder.scanning_parameters ) if not plate_hash_already_exists(extracted_plate.plate_hash): extracted_plates.append(extracted_plate) task_notifier.emit_task_progress(progress={ 'style': 'determinate', 'total': len(plate_files) + 2, 'current_state': idx + 1, 'message': f'Parsing {extracted_plate.label}...', }) socketio.sleep() else: task_notifier.emit_task_progress(progress={ 'style': 'determinate', 'total': len(plate_files), 'current_state': idx + 1, 'message': f"Cannot Process {extracted_plate.label}, Already Exists In Database." }) socketio.sleep() except Exception as e: # print("Exception Not Caught", e) task_notifier.emit_task_progress(progress={ 'style': 'determinate', 'total': len(plate_files), 'current_state': idx + 1, 'message': f"Cannot Process {plate_zip.filename}", }) socketio.sleep() finally: os.remove(plate_zip_file) task_notifier.emit_task_progress(progress={ 'style': 'determinate', 'total': len(plate_files) + 2, 'current_state': len(plate_files) + 1, 'message': f'Saving Plate Data...', }) socketio.sleep() submitted_plates = [Plate.from_extracted_plate(plate, ladder) for plate in extracted_plates] db.session.commit() socketio.sleep() task_notifier.emit_task_success(message={'ids': [plate.id for plate in submitted_plates]}) socketio.sleep() plate_zips = request.files.getlist('files') files = [] for f in plate_zips: handle, tmpfile_path = tempfile.mkstemp() tmpfile = os.fdopen(handle, mode='wb') tmpfile.write(f.stream.read()) files.append(tmpfile_path) ladder_id = request.form.get('ladder_id') socketio.start_background_task(bg_upload_plates, files, ladder_id) return jsonify({'status': "Success"})