def RunAcWindows(self): self.ActivationWindows.setDisabled(True) self.AcWindowsThread = Threads(2) self.AcWindowsThread.AotStepOneSignal.connect(self.OneWindowsBar) self.AcWindowsThread.AotStepTwoSignal.connect(self.TwoWindowsBar) self.AcWindowsThread.AotStepThreeSignal.connect(self.ThreeWindowsBar) self.AcWindowsThread.AotFinishSignal.connect(self.AcWindowsTips) self.AcWindowsThread.start()
def RunAcOffice(self): self.ActivationOffice.setDisabled(True) self.AcOfficeThread = Threads(3) self.AcOfficeThread.AotOfficePathError.connect(self.PathError) self.AcOfficeThread.AotStepOneSignal.connect(self.OneOfficeBar) self.AcOfficeThread.AotStepTwoSignal.connect(self.TwoOfficeBar) self.AcOfficeThread.AotStepThreeSignal.connect(self.ThreeOfficeBar) self.AcOfficeThread.AotFinishSignal.connect(self.AcOfficeTips) self.AcOfficeThread.GetUserDirSignal.connect(self.GetUserDir) self.AcOfficeThread.start()
def readline_stdin(self): if Threads.is_gui_thread(): raise RuntimeError, "Cannot call readline_stdin from GUI thread" if len(self.input_result) == 0: Threads.run_on_gui_thread(self.request_input) self.input_event.wait() self.input_event.clear() result = self.input_result self.input_result = "" return result
def write(self, data): console = None if "value" in dir(_python_console): console = _python_console.value if console is None: self.stdout.write(data) else: if self.error: Threads.run_on_gui_thread(lambda: console.write_stderr(data)) else: Threads.run_on_gui_thread(lambda: console.write_stdout(data))
def readline_stdin(self): if Threads.is_gui_thread(): raise RuntimeError("Cannot call readline_stdin from GUI thread") if len(self.input_result) == 0: Threads.run_on_gui_thread(self.request_input) self.input_event.wait() self.input_event.clear() result = self.input_result self.input_result = "" return result
def getGPSReport(self): if DataManager._gpsSession is False: #This starts a thread which self connects DataManager._gpsSession = Thrd.GpsPoller() DataManager._gpsSession.start() return DataManager._gpsSession.curReport
def FourNumCalc(numRange, expRange, minReq, board, operators): formulaCombos = cf.getFormulas(operators, True) group1, group2, group3 = cf.getNumCombs(numRange, expRange, True) outerDict, innerDict = th.StartThreads(formulaCombos, group1, group2, group3, board, minReq, True) return outerDict, innerDict
def startLaserShark(self, event): print "Connecting to OpenSL Printer..." self.connected = True self.disconnectFromLaserSharkButton.Enable() self.connectToLaserSharkButton.Disable() self.launch_openlase() self.loadPrintThread = Threads.PrintLoader()
def beginLog(self): #Make sure previous one is stopped DataManager.stopLog() DataManager.rwThread = Thrd.RWThread() DataManager.isRecording = True DataManager.rwThread.start()
def start_snapshot(self): self.Snap_Thread = Threads.Snap() self.Snap_Thread.transmit.connect(lambda: UI_Update.transmit_update(self)) self.Snap_Thread.started.connect(lambda: UI_Update.snap_start(self)) self.Snap_Thread.finished.connect(lambda: UI_Update.snap_complete(self)) self.Snap_Thread.start()
def onLongitudinalClicked(self): Ui_MainWindow.DisableAnalysisButtons(self) Ui_MainWindow.predictionArea = [0, 0, 0, 0] # Bools to keep track: Ui_MainWindow.goodPredicted = False Ui_MainWindow.badPredicted = False Ui_MainWindow.goodpredictionList = [] Ui_MainWindow.badpredictionList = [] #Make a messagebox to ask how you wanna do this: msgBox = QtWidgets.QMessageBox(self) msgBox.setWindowTitle("Assurance - Longitudinal analysis") msgBox.setText( "For this supervised approach you will need to set aside files that have not been included in the main dataset which will be randomly divided into test and training sets. You need to divide those files into examples of good and bad quality. How would you like to do so?" ) msgBox.addButton(QtWidgets.QPushButton('Select from graph of IDs'), QtWidgets.QMessageBox.YesRole) msgBox.addButton( QtWidgets.QPushButton('Select from table of quality metrics'), QtWidgets.QMessageBox.YesRole) msgBox.addButton(QtWidgets.QPushButton('Cancel'), QtWidgets.QMessageBox.RejectRole) ret = msgBox.exec_() if ret == 0: # They want the graph tpep = Threads.SideThread(self.GetTrainingSetTable) tpep.signals.result.connect(self.OnParserThreadFinish) self.threadpool.start(tpep) elif ret == 1: # They want the table FileInput.BrowseWindow.GetTrainingQualityFiles(self) if FileInput.BrowseWindow.NullError: QtWidgets.QMessageBox.warning( self, "Error", "Is it possible there may be unnecessary spaces in your tsv? Two spaces next to each other will create a NaN column.Fix the file and upload it again." ) FileInput.BrowseWindow.__init__(Ui_MainWindow) FileInput.BrowseWindow.GetTrainingQualityFiles(Ui_MainWindow) if hasattr(Ui_MainWindow, "Numerictrainingmetrics"): if len(Ui_MainWindow.Numerictrainingmetrics) > 0: Ui_MainWindow.TrainingOrTestSet = QtWidgets.QTabWidget() Ui_MainWindow.TrainingOrTestSet.setStyleSheet( "margin: 2px;") Ui_MainWindow.sIndex = self.addTab( Ui_MainWindow.TrainingOrTestSet, "Setting up the training set:") RandomForest.RandomForest.createTable(self) self.setCurrentIndex(Ui_MainWindow.sIndex) Ui_MainWindow.RandomForestPerformed = True Ui_MainWindow.pdf.setEnabled(True) else: QtWidgets.QMessageBox.warning(self, "Error", "Something went wrong.") else: Ui_MainWindow.EnableAnalysisButtons(self) elif ret == 2: #Cancelled Ui_MainWindow.EnableAnalysisButtons(self)
def read_stdin(self, size): if Threads.is_gui_thread(): raise RuntimeError, "Cannot call read_stdin from GUI thread" if len(self.input_result) == 0: Threads.run_on_gui_thread(self.request_input) self.input_event.wait() self.input_event.clear() if len(self.input_result) > size: result = self.input_result[0:size] self.input_result = self.input_result[size:] return result result = self.input_result self.input_result = "" return
def sensor_init(self): try: self.Sensor_Thread = Threads.Sensor() self.Sensor_Thread.update.connect( lambda: UI_Update.sensor_update(self)) self.Sensor_Thread.start() except Exception as e: print(e)
def sensor_init(self): os.system("i2cdetect -y 1 > ../_temp/output.txt") if '1f' in open('../_temp/output.txt').read(): self.Sensor_Thread = Threads.Sensor() self.Sensor_Thread.update.connect(lambda: UI_Update.sensor_update(self)) self.Sensor_Thread.start()
def read_stdin(self, size): if Threads.is_gui_thread(): raise RuntimeError("Cannot call read_stdin from GUI thread") if len(self.input_result) == 0: Threads.run_on_gui_thread(self.request_input) self.input_event.wait() self.input_event.clear() if len(self.input_result) > size: result = self.input_result[0:size] self.input_result = self.input_result[size:] return result result = self.input_result self.input_result = "" return
def snailInit(processMode): global Pflag Pflag = processMode VS.Init(processMode) MC.Init() Threads.ThreadInit(processMode) MC.SetMotor(cmd,250) time.sleep(1)
def start_sequence(self): if(Settings.image_format): Settings.file = Settings.full_dir + "/" + Settings.sequence_name + "_%04d.jpg" else: Settings.file = Settings.full_dir + "/" + Settings.sequence_name + "_%04d.png" self.Progress_Bar.setMaximum(Settings.total) try: if not Settings.timelapse_running: Functions.Camera_update(self) self.Imaging_Thread = Threads.Image() self.Imaging_Thread.started.connect( lambda: UI_Update.timelapse_update(self)) self.Imaging_Thread.finished.connect( lambda: UI_Update.timelapse_update(self)) self.Imaging_Thread.capturing.connect( lambda: UI_Update.imaging_disable(self)) self.Imaging_Thread.complete.connect( lambda: UI_Update.update_frame(self, Settings.current_image)) self.Imaging_Thread.start() else: Settings.timelapse_running = False UI_Update.timelapse_update(self) except Exception as e: print(e) if(Settings.storage_mode): try: if Settings.cloudTypeComboSelection == 0: print("Starting Dropbox Sync Thread") self.Dropbox_Thread = Threads.Dropbox() self.Dropbox_Thread.start() self.Email_Thread = Threads.Email() self.Email_Thread.start() elif Settings.cloudTypeComboSelection == 1: print("Starting Cyverse Sync Thread") self.Cyverse_Thread = Threads.Cyverse() self.Cyverse_Thread.start() except Exception as e: print(e)
def onBrowseClicked(self, database): FileInput.BrowseWindow.__init__(Ui_MainWindow) inputFiles = FileInput.BrowseWindow.GetInputFile(Ui_MainWindow) #Threading tbrowse = Threads.SideThread( lambda: self.ParseFiles(inputFiles, database)) tbrowse.signals.result.connect(self.ThreadingFix) self.threadpool.start(tbrowse)
def launch_openlase(self): print "Connecting to Serial " + self.serialport.GetValue( ) + "@ " + self.baud.GetValue() self.printerSerial.connect(self.serialport.GetValue(), self.baud.GetValue()) self.loadLaserSharkThread = Threads.Loader() self.launch_qjackctl() self.launch_openlase_output() self.launch_openlase_simulator() self.launch_lasershark_host_app()
def start_preview(self): self.Preview_Thread = Threads.Preview() self.Preview_Thread.transmit.connect( lambda: UI_Update.transmit_update(self)) self.Preview_Thread.started.connect(lambda: UI_Update.snap_start(self)) self.Preview_Thread.finished.connect( lambda: UI_Update.preview_complete(self)) self.Preview_Thread.start()
def __init__(self, database, remembral_settings): self.__buttons = Buttons.Buttons() self.__database = database self.__remembral_settings = remembral_settings self.__threads = Threads.Threads(self.__database, self.__buttons) self.__commandStart = CommandStart.CommandStart(self.__database, self.__buttons) self.__buttonPressShow = ButtonPressShow.ButtonPressShow(self.__database, self.__buttons) self.__buttonPressDelete = ButtonPressDelete.ButtonPressDelete(self.__database, self.__threads) self.__buttonPressTransfer = ButtonPressTransfer.ButtonPressTransfer(self.__database, self.__threads, self.__buttons) self.__buttonPressCreate = ButtonPressCreate.ButtonPressCreate(self.__threads, self.__database, self.__buttons, self.__buttonPressTransfer) self.__remembrall = None
def getSpeed(self): if DataManager._hallSpeedSess is False: DataManager._hallSpeedSess = Thrd.HallSensors(DataManager.isEmulate) DataManager._hallSpeedSess.start() TotS = 0; for i in range(1,3): obj = DataManager._hallSpeedSess; TotS = TotS + (obj.stamps[i][0] - obj.stamps[i][1]) return 1/((TotS/6)*21) #rev/s
def start_livefeed(self): try: Settings.livetime = self.liveFeed_spinBox.value() self.livefeed_Thread = Threads.Live() self.livefeed_Thread.started.connect( lambda: UI_Update.imaging_disable(self)) self.livefeed_Thread.finished.connect( lambda: UI_Update.imaging_enable(self)) self.livefeed_Thread.start() except Exception as e: print(e)
def start_snapshot(self): try: Functions.Camera_update(self) self.Snap_Thread = Threads.Snap() self.Snap_Thread.started.connect( lambda: UI_Update.imaging_disable(self)) self.Snap_Thread.finished.connect( lambda: UI_Update.update_frame_snap(self, "../_temp/snapshot.jpg")) self.Snap_Thread.start() except Exception as e: print(e)
def start_snapshot(self): try: self.Snap_Thread = Threads.Snap() self.Snap_Thread.transmit.connect(lambda: UI_Update.transmit_update(self)) self.Snap_Thread.started.connect(lambda: UI_Update.imaging_start(self)) self.Snap_Thread.finished.connect(lambda: UI_Update.snap_complete(self)) self.Snap_Thread.ir.connect(lambda: self.ir_imaging()) self.Snap_Thread.start() except Exception as e: print(e)
def start_preview(self): try: self.Preview_Thread = Threads.Preview() self.Preview_Thread.transmit.connect(lambda: UI_Update.transmit_update(self)) self.Preview_Thread.started.connect(lambda: UI_Update.imaging_start(self)) self.Preview_Thread.finished.connect(lambda: UI_Update.preview_complete(self)) self.Preview_Thread.ir.connect(lambda: self.ir_imaging()) self.Preview_Thread.start() except Exception as e: print(e)
def CV_authenticate(self): Settings.cyverseUsername = self.cyverseUsername_lineEdit.text() Settings.cyversePassword = self.cyversePassword_lineEdit.text() try: self.Auth_Thread = Threads.Auth() self.Auth_Thread.started.connect( lambda: UI_Update.CV_authenticating(self)) self.Auth_Thread.finished.connect( lambda: UI_Update.CV_authenticated(self)) self.Auth_Thread.start() except Exception as e: print(e)
def start_cycle(self): if not Settings.cycle_running: try: self.Cycle_Thread = Threads.Cycle() self.Cycle_Thread.started.connect(lambda: UI_Update.cycle_start(self)) self.Cycle_Thread.finished.connect(lambda: UI_Update.cycle_end(self)) self.Cycle_Thread.start() except Exception as e: print(e) else: Settings.cycle_running = False
def start_cycle(self): if not Settings.cycle_running: try: Settings.cycle_time = self.powerCycle_spinBox.value() self.Cycle_Thread = Threads.Cycle() self.Cycle_Thread.started.connect( lambda: UI_Update.cycle_update(self)) self.Cycle_Thread.start() except Exception as e: print(e) else: Settings.cycle_running = False UI_Update.cycle_update(self)
def start_cycle(self): if not Settings.cycle_running: try: self.Cycle_Thread = Threads.Cycle() self.Cycle_Thread.started.connect( lambda: UI_Update.cycle_start(self)) self.Cycle_Thread.finished.connect( lambda: UI_Update.cycle_end(self)) self.Cycle_Thread.start() except Exception as e: print(e, "cycle failure, please contact Jerry for support") else: Settings.cycle_running = False
def start_preview(self): try: Functions.Camera_update(self) self.Preview_Thread = Threads.Preview() self.Preview_Thread.started.connect( lambda: UI_Update.imaging_disable(self)) if(Settings.image_format): self.Preview_Thread.finished.connect( lambda: UI_Update.update_frame_alt(self, "../_temp/preview.jpg")) else: self.Preview_Thread.finished.connect( lambda: UI_Update.update_frame_alt(self, "../_temp/preview.png")) self.Preview_Thread.start() except Exception as e: print(e)
def schedule_test(self): if not Settings.test_running: try: Settings.angle_1 = self.rotate1_spinbox.value() Settings.angle_2 = self.rotate2_spinbox.value() self.Test_Thread = Threads.Test() self.Test_Thread.started.connect( lambda: UI_Update.test_update(self)) self.Test_Thread.finished.connect( lambda: UI_Update.test_update(self)) self.Test_Thread.start() except Exception as e: print(e) else: Settings.test_running = False UI_Update.test_update(self)
def __init__(self, console): threading.Thread.__init__(self) self.console = console self.globals = {"__name__":"__console__", "__doc__":None} self.code = None self.event = threading.Event() self.done = threading.Event() self.exit = False self.interpreter = code.InteractiveInterpreter(self.globals) # There is no way to interrupt a thread that isn't the main thread, so # to avoid not being able to close the app, create the thread as # as daemon thread. self.daemon = True # Set up environment with useful variables and functions self.globals["data"] = Threads.GuiObjectProxy(self.console.view.data) self.globals["exe"] = Threads.GuiObjectProxy(self.console.view.exe) self.globals["view"] = Threads.GuiObjectProxy(self.console.view) self.globals["current_view"] = Threads.GuiObjectProxy(lambda: self.console.view.view) self.globals["change_view"] = Threads.GuiObjectProxy(lambda type: self.console.view.setViewType(type)) self.globals["navigate"] = Threads.GuiObjectProxy(lambda type, pos: self.console.view.navigate(type, pos)) self.globals["create_file"] = Threads.GuiObjectProxy(lambda data: Threads.create_file(data)) self.globals["cursor"] = Threads.GuiObjectProxy(lambda: self.console.view.view.get_cursor_pos()) self.globals["set_cursor"] = Threads.GuiObjectProxy(lambda pos: self.console.view.view.set_cursor_pos(pos)) self.globals["selection_range"] = Threads.GuiObjectProxy(lambda: self.console.view.view.get_selection_range()) self.globals["set_selection_range"] = Threads.GuiObjectProxy(lambda start, end: self.console.view.view.set_selection_range(start, end)) self.globals["selection"] = Threads.GuiObjectProxy(lambda: self.get_selection()) self.globals["replace_selection"] = Threads.GuiObjectProxy(lambda value: self.replace_selection(value)) self.globals["write_at_cursor"] = Threads.GuiObjectProxy(lambda value: self.write_at_cursor(value)) self.globals["undo"] = Threads.GuiObjectProxy(lambda: self.console.view.undo()) self.globals["redo"] = Threads.GuiObjectProxy(lambda: self.console.view.redo()) self.globals["commit"] = Threads.GuiObjectProxy(lambda: self.console.view.commit_undo()) self.globals["copy"] = Threads.GuiObjectProxy(lambda value: self.copy(value)) self.globals["paste"] = Threads.GuiObjectProxy(lambda: self.console.view.view.paste()) self.globals["clipboard"] = Threads.GuiObjectProxy(lambda: self.get_clipboard())