def run(self): try: result = {'switch_count': None, 'max_keys': None} serial_connection = serial.Serial() serial_connection.baudrate = 9600 serial_connection.port = self.port serial_connection.open() if serial_connection.is_open: serial_connection.write(bytearray([0xEE, 0x02, 0xFF])) response = [] while (len(response) == 0 or response[-1] != b'\xff'): byte = serial_connection.read() response.append(byte) result['switch_count'] = response[2][0] result['max_keys'] = response[3][0] CallAfter(pub.sendMessage, "serial", class_name=type(self).__name__, data=result) else: raise Exception("serial_connection is closed") serial_connection.close() except Exception: CallAfter(pub.sendMessage, "serial", class_name="ConnectionError", data=None)
def run(self): try: url = Smms.upload(self.filename, token=self.token) copy(url) CallAfter(self.window.UploadSuccess) except ConnectionRefusedError: CallAfter(self.window.LoginAgain) except ConnectionAbortedError: CallAfter(self.window.UploadMax)
def run(self): try: self.pipeline.loadRawData() except AnalysisPipelineError as err: PostEvent( self.pipeline.attachedUI.parent, ExecutionCompletedEvent(err, self.pipeline.EXECUTION_COMPLETE_ID)) self.pipeline.eventProgress = -1 return except Exception as err: PostEvent( self.pipeline.attachedUI.parent, ExecutionCompletedEvent(err, self.pipeline.EXECUTION_COMPLETE_ID)) return numExecutedModules = 0 returnedData = self.pipeline.rawData for module in self.pipeline.activeModules: self.pipeline.eventProgress = int( 100 * float(numExecutedModules) / float(len(self.pipeline.activeModules))) try: module.executeModule(returnedData) except AnalysisModules.ModuleExecutionError as err: PostEvent( self.pipeline.attachedUI.parent, ExecutionCompletedEvent( err, self.pipeline.EXECUTION_COMPLETE_ID)) self.pipeline.eventProgress = -1 return except Exception as err: PostEvent( self.pipeline.attachedUI.parent, ExecutionCompletedEvent( err, self.pipeline.EXECUTION_COMPLETE_ID)) return returnedData = module.getOutput() numExecutedModules += 1 self.pipeline.rawData = returnedData self.pipeline.eventProgress = -1 PostEvent( self.pipeline.attachedUI.parent, ExecutionCompletedEvent(None, self.pipeline.EXECUTION_COMPLETE_ID)) # UI specific statements below. CallAfter call will execute these statements after # the thread terminates (I believe). UI will crash otherwise. CallAfter(self.pipeline.attachedUI.parent.loadDataTab.populateRunList) CallAfter(self.pipeline.attachedUI.parent.MainLog.WriteLogText, "Done.") CallAfter(self.pipeline.clearAttachedUI ) # Clear the attached UI so that it is not saved to file.
def attach_app(self, rceapps, jobid, ad): try: CallAfter(pub.sendMessage, 'rce_submit.xpra_attached', pid=self.rce.attach(jobid, rceapps, ad=ad), excpt=None) except Exception as e: CallAfter(pub.sendMessage, 'rce_submit.xpra_attached', pid=None, excpt=e)
def poll_app(self, jobid): try: job_status, ad = self.rce.poll(jobid, use_local_schedd=True) CallAfter(pub.sendMessage, 'rce_submit.job_started', job_status=job_status, ad=ad, excpt=None) except Exception as e: CallAfter(pub.sendMessage, 'rce_submit.job_started', job_status=None, ad=None, excpt=e)
def loop(self): if self._printer._pause.isSet(): return None if self._printer._waiting_response.isSet(): return None if not self._printer._commands_queue.empty(): self._printer._waiting_response.set() name, command, args = self._printer._commands_queue.get() CallAfter(self._printer.OnCommand, name, command, args) if name == 'wait': time.sleep(command / 1000) CallAfter(self._printer.OnReadLine, 'ok') CallAfter(self._printer._waiting_response.clear) else: CallAfter(self._printer.Write, command)
def run(self): try: result = {} for index, port in enumerate(serial.tools.list_ports.comports()): device_label = "{} - {}".format(port.device, port.description) result[device_label] = port.device CallAfter(pub.sendMessage, "serial", class_name=type(self).__name__, data=result) except Exception: CallAfter(pub.sendMessage, "serial", class_name="ConnectionError", data=None)
def run(self): """ Returns weather the update checking was successful. :rtype: Boolean """ try: padfile = CHECK_UPDATE.get_pad() if padfile is None: _logger().exception('Pad could not be found in URL.') return tree = parse(padfile) except urllib2.URLError: _logger().exception('Update checker exception retrieving pad-file') return except XMLSyntaxError: _logger().exception('Update checker exception parsing pad-file') return except ParseError: _logger().exception('Update checker exception parsing pad-file') return except Exception as excp: logstr = 'Update checker exception, generic: {exception!s}' _logger().exception(logstr.format(exception=excp)) return self.latest_version = tree.findtext('Program_Info/Program_Version') url_p = 'Web_Info/Download_URLs/Primary_Download_URL' url_s = 'Web_Info/Download_URLs/Secondary_Download_URL' url_primary = tree.findtext(url_p) url_secondary = tree.findtext(url_s) url = url_primary if url_primary else url_secondary if self.latest_version > diwavars.VERSION and url is not None: CallAfter(self.show_dialog, url)
def on_press(self, key): try: if key.value.vk not in current_key_pressed: current_key_pressed.append(key.value.vk) except AttributeError: if key.vk not in current_key_pressed: current_key_pressed.append(key.vk) if self.is_pressed(): status = get_pic_from_clipboard(self.window) # toaster = ToastNotifier() if status: CallAfter(self.window.Uploading) else: CallAfter(self.window.UploadFailed)
def import_db(cnx_src, cnx_dst, callback=None, force=False): """ :param cnx_src: the source DVHA DB connection :type cnx_src: DVH_SQL :param cnx_dst: the destination DVHA DB connection :type cnx_dst: DVH_SQL :param callback: optional function to be called on each row insertion :param force: ignore duplicate StudyInstanceUIDs if False :type force: bool """ for table in cnx_src.tables: columns = cnx_src.get_column_names(table) study_uids_1 = cnx_src.get_unique_values(table, 'study_instance_uid') condition = None if not force: study_uids_2 = cnx_dst.get_unique_values(table, 'study_instance_uid') study_uids_1 = list(set(study_uids_1) - set(study_uids_2)) condition = "study_instance_uid IN ('%s')" % "','".join(study_uids_1) total_row_count = cnx_src.get_row_count(table, condition) counter = 0 for uid in study_uids_1: study_data = cnx_src.query(table, ','.join(columns), "study_instance_uid = '%s'" % uid) for row in study_data: if callback is not None: CallAfter(callback, table, counter, total_row_count) counter += 1 row_str = "'" + "','".join([str(v) for v in row]) + "'" row_str = row_str.replace("'None'", "NULL") cmd = "INSERT INTO %s (%s) VALUES (%s);\n" % (table, ','.join(columns), row_str) cnx_dst.execute_str(cmd)
def create_event(self, title): """ Create a new event. :param title: Title of the event. :type title: String """ project = self.parent.diwa_state.current_project session = self.parent.diwa_state.current_session if (project is None) or (session is None): return # TODO: Define a new exception type and catch # it in the UI design to display an # informative pop-up about project and # session. event_id = controller.add_event(session.id, title, '') SNAPSHOT_THREAD(project.dir) try: self.parent.diwa_state.swnp_send('SYS', 'screenshot;0') if diwavars.AUDIO and self.parent.diwa_state.audio_recorder: log_msg = 'Buffering audio for {0} seconds.' _logger().debug(log_msg.format(diwavars.WINDOW_TAIL)) #self.parent.status_text.SetLabel('Recording...') self.parent.diwa_state.append_swnp_data('audio') self.parent.UpdateScreens(update=True) parameters = (event_id, project.dir) CallAfter(self.__save_audio, parameters) except: _logger().exception('Create Event exception.') self.parent.diwa_state.remove_from_swnp_data('audio')
def save(self, event_id, path): """ Save the buffer to a file. """ try: _logger().debug('Saving audio buffer') date_string = datetime.now().strftime('%d%m%Y%H%M') filename = '{0}_{1}.wav'.format(event_id, date_string) filepath = os.path.join(path, 'Audio') if not os.path.exists(filepath): os.makedirs(filepath) filepath = os.path.join(filepath, filename) sample_size = self.py_audio.get_sample_size(diwavars.FORMAT) wave_file = wave.open(filepath, 'wb') wave_file.setnchannels(diwavars.CHANNELS) wave_file.setsampwidth(sample_size) wave_file.setframerate(diwavars.RATE) wave_file.writeframes(b''.join(self.buffer)) wave_file.close() except: _logger().exception('audio save exception') #CallAfter(self.parent.ClearStatusText) self.parent.diwa_state.remove_from_swnp_data('audio') CallAfter(self.parent.UpdateScreens(update=True))
def update_loop(self, inp_file=None, force_update=False, delay_time=1, data_model=3.0): print("-I- checking for updates at {0}".format(asctime())) if self.inp_file is None: inp_file_names = self.get_all_inp_files(self.WD) if inp_file_names == []: print("-W- No inp files found in any subdirectories of " "%s, aborting update checking thread" % self.WD) self.timer.Stop() return magic_files = {} update_list = [] for inp_file_name in inp_file_names: update_list.append( self.read_inp(self.WD, inp_file_name, magic_files, data_model)) update_needed = any(update_list) else: inp_file_name = self.inp_file magic_files = {} update_needed = self.read_inp(self.WD, inp_file_name, magic_files, data_model) if update_needed or force_update: print("-I- Resetting...") self.combine_magic_files(self.WD, magic_files, data_model=data_model) CallAfter(self.reset_backend, warn_user=False, reset_interps=False) print("-I- Reset")
def enable_inputs(self): if self.__nonzero__(): self.m_btnseek.Enable() self.m_staticTextcopy.Enable() self.m_account.Enable() self.is_change.Enable() self.m_index.Enable() CallAfter(self.Enable)
def _on_process_ended(self): """ iplayer_get process has finished """ # use CallAfter to switch back to the main GUI thread CallAfter(Publisher().sendMessage, topic=Channels.TOPIC_REFRESH_COMPLETE, data=self) self.is_refreshing = False self._process = None
def _on_process_timer(self, event=None): for (episode, process) in self._processes: self.read_episode(episode, process) # use CallAfter to switch back to the main GUI thread CallAfter(Publisher().sendMessage, topic=self.TOPIC_DOWNLOAD_PROGRESS) if len(self._processes) > 0: self._start_process_timer()
def _on_process_error(self, message): """ iplayer_get process returned an error """ # use CallAfter to switch back to the main GUI thread CallAfter(Publisher().sendMessage, topic=Channels.TOPIC_REFRESH_ERROR, data=self) self.error_message = message self.is_refreshing = False self._process = None
def run(self): try: serial_connection = serial.Serial() serial_connection.baudrate = 9600 serial_connection.port = self.port serial_connection.open() if serial_connection.is_open: keys_edit = [] for switch_index in range(0, self.switch_count): serial_connection.write( bytearray([0xEE, 0x00, switch_index, 0xFF])) response = [] while (len(response) == 0 or response[-1] != b'\xff'): byte = serial_connection.read() response.append(byte) converted_chars = [] for char in response[3:len(response) - 1]: if char[0] >= 33 and char[0] <= 126: converted_chars.append(chr(char[0])) else: try: converted_chars.append( KEY_TO_HEX_BIDICT.inv[char[0]]) except KeyError: continue if len(converted_chars) == 0: keys_edit.append(" ") else: keys_edit.append(" ".join(converted_chars)) keys_edit = "\n".join(keys_edit) CallAfter(pub.sendMessage, "serial", class_name=type(self).__name__, data=keys_edit) else: raise Exception("serial_connection is closed") serial_connection.close() except Exception: CallAfter(pub.sendMessage, "serial", class_name="ConnectionError", data=None)
def processChecker(process, procName): from time import sleep # The time interval to check for process messages [s]. checkInterval = 2 # The timeout limit. After this timeout the process is # marked as "not responding". The timeout interval should # be larger than the process's heartbeat interval. [s] timeout = 10 procRunning = True isZombie = False self.logger.debug("Checking process...") lastResponse = 0 while procRunning: #self.logger.debug("Waiting for message...") procStatus = proc.poll() #self.logger.debug('procStatus: %s', procStatus) if procStatus != None: procRunning = False #self.logger.debug('Process %d has stopped with return code %s.', proc.pid, procStatus) msgTopic = 'state.collection.execution' msg['state'] = 'stopped' msg['pid'] = proc.pid msg['procName'] = procName msg['curTime'] = datetime.now() CallAfter(pub.sendMessage, msgTopic, msg=msg) else: #self.logger.debug('Process %d is still running.', proc.pid) msgTopic = 'state.collection.execution' msg['state'] = 'running' msg['pid'] = proc.pid msg['procName'] = procName msg['curTime'] = datetime.now() CallAfter(pub.sendMessage, msgTopic, msg=msg) sleep(checkInterval)
def run(self): try: serial_connection = serial.Serial() serial_connection.baudrate = 9600 serial_connection.port = self.port serial_connection.open() if serial_connection.is_open: key_lines = self.keys_edit.splitlines() while len(key_lines) < self.switch_count: key_lines.append('') for index, key_list in enumerate(key_lines): serial_request = [0xEE, 0x01, index] for index, key in enumerate(key_list.split()): if index >= self.max_keys: break if len(key) > 1: try: serial_request.append(KEY_TO_HEX_BIDICT[key]) except KeyError: continue elif ord(key) >= 33 and ord(key) <= 126: serial_request.append(ord(key)) serial_request.append(0xFF) serial_connection.write(bytearray(serial_request)) time.sleep(0.1) serial_connection.reset_input_buffer() CallAfter(pub.sendMessage, "serial", class_name=type(self).__name__, data=True) else: raise Exception("serial_connection is closed") serial_connection.close() except Exception: CallAfter(pub.sendMessage, "serial", class_name="ConnectionError", data=None)
def _on_process_ended(self, episode): episode.download_state = self.DOWNLOAD_COMPLETE if episode.error_message is None: episode.download_message = "Downloaded" topic = self.TOPIC_DOWNLOAD_COMPLETE else: episode.download_message = "Error: %s" % episode.error_message topic = self.TOPIC_DOWNLOAD_ERROR # use CallAfter to switch back to the main GUI thread CallAfter(Publisher().sendMessage, topic=topic, data=episode)
def __init__(self, parent, context, send_file, handle_file): DIWA_THREAD.__init__(self, name='CMFH') self.parent = parent self.send_file = send_file self.handle_file = handle_file self.context = context try: self.socket = context.socket(zmq.REP) self.socket.setsockopt(zmq.LINGER, 0) self.socket.bind('tcp://*:5555') except zmq.ZMQError: CallAfter(parent.OnExit, ContextMenuFailure())
def __login(self, **kwargs): print "login" password = kwargs.get('password') account = kwargs.get('account') code, response, traceback = JIRA.authorization(account=account, password=password) if code == 0: CallAfter(self.update, ) kwargs.get('dialog').Destroy() # 下面代码没有调试过 elif code == 1: pass elif code == 2: print 'Please visit the \'https://jira-cstm.qualcomm.com/\' and check the connection.'
def __on_save_audio(self, id_, param): """ Save audio handler. """ id_ = id_ param = param project = self.parent.diwa_state.current_project if project is None: return 'OK' if self.parent.diwa_state.is_responsive and diwavars.AUDIO: event_id = controller.get_latest_event_id() timer = threading.Timer(diwavars.WINDOW_TAIL * 1000, self.parent.audio_recorder.save, event_id, project.dir) timer.start() CallAfter(self.parent.status_text.SetLabel, 'Recording...') return 'OK'
def _talk_to_gui(self, data): """Send data back to the GUI using wxCallAfter and wxPublisher. Args: data (string): Unique signal string that informs the GUI for the download process. Note: DownloadManager supports 3 signals. 1) closing: The download process is closing. 2) closed: The download process has closed. 3) finished: The download process was completed normally. """ CallAfter(Publisher.sendMessage, MANAGER_PUB_TOPIC, data)
def _on_finished(self): if self.error_message is None: self._episode.download_message = "Finished" topic = self.TOPIC_STREAMING_COMPLETE else: self._episode.download_message = ("Error: %s" % self.error_message) topic = self.TOPIC_STREAMING_ERROR # use CallAfter to switch back to the main GUI thread CallAfter(Publisher().sendMessage, topic=topic, data=self._episode)
def save_to_json(self, file_path, callback=None): """ :param file_path: file_path to new JSON file :type file_path: str :param callback: optional function to be called on each table insertion """ json_data = {'columns': {'categorical': categorical, 'numerical': numerical}} for i, table in enumerate(self.tables): if callback is not None: CallAfter(callback, table, i, len(self.tables)) columns = self.get_column_names(table) json_data[table] = self.query(table, ','.join(columns), bokeh_cds=True) with open(file_path, 'w') as fp: json.dump(json_data, fp)
def _talk_to_gui(self, data): """Send data back to the GUI using wxCallAfter and wxPublisher. Args: data (string): Unique signal string that informs the GUI for the download process. Note: DownloadManager supports 4 signals. 1) closing: The download process is closing. 2) closed: The download process has closed. 3) finished: The download process was completed normally. 4) report_active: Signal the gui to read the number of active downloads using the active() method. """ CallAfter(Publisher.sendMessage, MANAGER_PUB_TOPIC, msg=data)
def __query(self, **kwargs): start = kwargs.get('start') search = kwargs.get('query') end = start + GlobalVariable.max_result self.data.set_search_string(search) code, response, traceback = JIRA.qurey(search=search, start=start) if code == 0: self.parse_response(response=response) self.data.set_data(start=start, end=end) CallAfter(self.update, ) kwargs.get('dialog').stop() # 下面代码没有调试过 elif code == 1: JIRA.authorization(account=GlobalVariable.account, password=GlobalVariable.password) self.__query(**kwargs) elif code == 2: print 'Please visit the \'https://jira-cstm.qualcomm.com/\' and check the connection.'
def uiCalibrateCamera(self): imdata = self.acquireImage() if 'dose rate' not in self.results or self.results['dose rate'] is None: e = 'Unable to calibrate camera sensitivity: no dose measurement' self.logger.error(e) return try: sens = self.calclient.sensitivity_from_imagedata( imdata, self.results['dose rate']) except ValueError: e = 'Unable to calibrate camera sensitivity: invalid dose measurement' self.logger.error(e) return self.sens = sens ht = imdata['scope']['high tension'] self.calclient.storeSensitivity(ht, sens) CallAfter(self.panel.dialog.scrsettings._setSensitivityResults, sens)