def on_connect_clicked(self): self.s = serial.Serial(self.portsList.currentText(), baudrate=9600, timeout=1) self.s2 = serial.Serial(self.monitoringPort.currentText(), baudrate=115200, timeout=100) res = self.s.readline().decode('ascii') try: jMessage = json.loads(res) self.set_defaults_from_machine(jMessage) except: jMessage = {} self.worker = WorkerThread(self.s) self.workerThread = QThread() self.workerThread.started.connect(self.worker.run) self.worker.signal.connect(self.write_info) self.worker.moveToThread(self.workerThread) self.workerThread.start() self.worker2 = WorkerThread2(self.s2) self.workerThread2 = QThread() self.workerThread2.started.connect(self.worker2.run) self.worker2.signal.connect(self.write_patient_monitoring) self.worker2.moveToThread(self.workerThread2) self.workerThread2.start()
def __init__(self): QWidget.__init__(self) self.styles = load_styles() self.image = StyledCapture(QImage(256, 256, QImage.Format_RGB888), '') # placeholder self.freeze = None if isinstance(settings.CAPTURE_HANDLER, string_types): self.capture_handler = locate(settings.CAPTURE_HANDLER) else: self.capture_handler = settings.CAPTURE_HANDLER self.setup_ui() self.frame_grabber = FrameGrabber(settings.SIZES[0]) self.frame_thread = QThread() # self.frame_grabber.image_signal.connect(self.display_frame) self.frame_grabber.last_frame_signal.connect(self.last_frame) self.frame_grabber.moveToThread(self.frame_thread) self.frame_thread.started.connect(self.frame_grabber.grab) self.stop_signal.connect(self.frame_grabber.stop_work) self.quality_changed.connect(self.frame_grabber.change_size) self.frame_thread.start() self.image_processor = ImageProcessor(self.styles[0]) self.image_thread = QThread() self.image_processor.image_signal.connect(self.display_frame) self.image_processor.moveToThread(self.image_thread) self.image_thread.started.connect(self.image_processor.monitor_images) self.stop_signal.connect(self.image_processor.stop_work) self.style_changed.connect(self.image_processor.change_style) self.last_frame_changed.connect(self.image_processor.change_last_frame) self.image_thread.start()
def __init__(self, tracker: Tracker) -> None: super().__init__() self.qttracker = QtTracker(tracker) self.bg_thread = QThread(self) self.qttracker.moveToThread(self.bg_thread) self.bg_thread.start() self.qttracker.start_recording() self.setCentralWidget(Controls(self.qttracker)) toolbar = QToolBar() self.addToolBar(toolbar) toolbar.setMovable(False) toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon) self.new_action = QAction("New", self) self.new_action.setToolTip("Create a new file for tracking.") icon = self.style().standardIcon(QStyle.SP_FileIcon) self.new_action.setIcon(icon) self.new_action.triggered.connect(self.new_db) toolbar.addAction(self.new_action) self.load_action = QAction("Load", self) self.load_action.setToolTip("Load a existing file for tracking.") icon = self.style().standardIcon(QStyle.SP_DialogOpenButton) self.load_action.setIcon(icon) self.load_action.triggered.connect(self.load_db) toolbar.addAction(self.load_action)
def startSimulation(self): self._run_model.reset() self._snapshot_model.reset() self._tab_widget.clear() def run(): asyncio.set_event_loop(asyncio.new_event_loop()) self._run_model.startSimulations(self._simulations_argments) simulation_thread = Thread(name="ert_gui_simulation_thread") simulation_thread.setDaemon(True) simulation_thread.run = run simulation_thread.start() self._ticker.start(1000) tracker = create_tracker( self._run_model, num_realizations=self._simulations_argments["active_realizations"]. count(), ee_config=self._simulations_argments.get("ee_config", None), ) worker = TrackerWorker(tracker) worker_thread = QThread() worker.done.connect(worker_thread.quit) worker.consumed_event.connect(self._on_tracker_event) worker.moveToThread(worker_thread) self.simulation_done.connect(worker.stop) self._worker = worker self._worker_thread = worker_thread worker_thread.started.connect(worker.consume_and_emit) self._worker_thread.start()
def setup_midi_thread(self): self.midithread = QThread() self.midiworker = MidiWorker(self.config) self.midiworker.moveToThread(self.midithread) self.midithread.started.connect(self.midiworker.initialize) self.midiworker.send_patch_start.connect( partial(self.mainwin.set_send_action_enabled, False)) self.midiworker.send_patch_complete.connect( partial(self.mainwin.set_send_action_enabled, True)) self.midiworker.recv_patch_start.connect( partial(self.mainwin.set_request_action_enabled, False)) self.midiworker.recv_patch_complete.connect(self.receive_patch) self.midiworker.recv_patch_failed.connect( partial(self.mainwin.set_request_action_enabled, True)) self.midiworker.input_ports_changed.connect( self.build_midi_input_selector) self.midiworker.output_ports_changed.connect( self.build_midi_output_selector) # Start thread self.midithread.start() self.timer = QTimer() self.timer.timeout.connect(self.midiworker.scan_ports.emit) self.timer.start(3000)
def on_incoming_connection(self, socket_descriptor: int) -> None: """Create new client thread. Args: socket_descriptor (int): Socket descriptor. """ client_id = self.get_free_id() thread = QThread() thread.setObjectName(str(client_id)) client = _SocketClient(socket_descriptor, client_id) client.moveToThread(thread) thread.started.connect(client.run) # noqa client.connected.connect(self.connected.emit) client.message.connect(self.message.emit) client.error.connect(self.error.emit) client.disconnected.connect(self.on_client_disconnected) client.disconnected.connect(thread.quit) client.disconnected.connect(thread.wait) thread.finished.connect(self.on_thread_finished) self.clients.append(client) self.threads.append(thread) thread.start() self._logger.info("Started new client thread!") self._logger.debug("Active clients: {}".format(len([x for x in self.threads if x.isRunning()])))
def download(self): self.downloadButton.setEnabled(False) self.setStatus(config.thisTranslation["message_installing"]) self.closeButton.setEnabled(False) folder = os.path.join("audio", "bibles") if not os.path.exists(folder): os.mkdir(folder) folder = os.path.join("audio", "bibles", self.selectedText) if not os.path.exists(folder): os.mkdir(folder) folder = os.path.join("audio", "bibles", self.selectedText, self.selectedDirectory) if not os.path.exists(folder): os.mkdir(folder) self.thread = QThread() self.worker = DownloadFromGitHub(self.github, self.repoData, self.dataViewModel, self.selectedText, self.selectedDirectory) self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.run) self.worker.finished.connect(self.thread.quit) self.worker.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.worker.deleteLater) self.worker.finished.connect(self.finishedDownloading) self.worker.progress.connect(self.setStatus) self.thread.start()
def restart_kernel(self): """ Restart the associated kernel. Took this code from the qtconsole project Licensed under the BSD license """ sw = self.shellwidget if not running_under_pytest() and self.ask_before_restart: message = _('Are you sure you want to restart the kernel?') buttons = QMessageBox.Yes | QMessageBox.No result = QMessageBox.question(self, _('Restart kernel?'), message, buttons) else: result = None if (result == QMessageBox.Yes or running_under_pytest() or not self.ask_before_restart): if sw.kernel_manager: if self.infowidget is not None: if self.infowidget.isVisible(): self.infowidget.hide() if self._abort_kernel_restart(): sw.spyder_kernel_comm.close() return self._show_loading_page() # Close comm sw.spyder_kernel_comm.close() # Stop autorestart mechanism sw.kernel_manager.stop_restarter() sw.kernel_manager.autorestart = False # Reconfigure client before the new kernel is connected again. self._before_prompt_is_ready(show_loading_page=False) # Create and run restarting thread if (self.restart_thread is not None and self.restart_thread.isRunning()): self.restart_thread.finished.disconnect() self.restart_thread.quit() self.restart_thread.wait() self.restart_thread = QThread(None) self.restart_thread.run = self._restart_thread_main self.restart_thread.error = None self.restart_thread.finished.connect( lambda: self._finalise_restart(True)) self.restart_thread.start() else: sw._append_plain_text( _('Cannot restart a kernel not started by Spyder\n'), before_prompt=True ) self._hide_loading_page()
def _start(self): """Start threads and check for inactive workers.""" if self._queue_workers and self._running_threads < self.MAX_THREADS: # print('Queue: {0} Running: {1} Workers: {2} ' # 'Threads: {3}'.format(len(self._queue_workers), # self._running_threads, # len(self._workers), # len(self._threads))) self._running_threads += 1 thread = QThread() worker = self._queue_workers.popleft() worker.moveToThread(thread) worker.sig_finished.connect(thread.quit) thread.started.connect(worker.start) thread.start() self._threads.append(thread) if self._workers: for w in self._workers: if w.is_finished(): self._bag_collector.append(w) self._workers.remove(w) if self._threads: for t in self._threads: if t.isFinished(): self._threads.remove(t) self._running_threads -= 1 if len(self._threads) == 0 and len(self._workers) == 0: self._timer.stop() self._timer_worker_delete.start()
def startSimulation(self): self._run_model.reset() self._snapshot_model.reset() self._tab_widget.clear() evaluator_server_config = EvaluatorServerConfig() def run(): asyncio.set_event_loop(asyncio.new_event_loop()) self._run_model.startSimulations( evaluator_server_config=evaluator_server_config, ) simulation_thread = Thread(name="ert_gui_simulation_thread") simulation_thread.setDaemon(True) simulation_thread.run = run simulation_thread.start() self._ticker.start(1000) tracker = EvaluatorTracker( self._run_model, ee_con_info=evaluator_server_config.get_connection_info(), ) worker = TrackerWorker(tracker) worker_thread = QThread() worker.done.connect(worker_thread.quit) worker.consumed_event.connect(self._on_tracker_event) worker.moveToThread(worker_thread) self.simulation_done.connect(worker.stop) self._worker = worker self._worker_thread = worker_thread worker_thread.started.connect(worker.consume_and_emit) self._worker_thread.start()
def shutdown(self, shutdown_kernel=True): """Shutdown connection and kernel.""" if self.shutting_down: return self.shutting_down = True if shutdown_kernel: if not self.kernel_manager: return self.interrupt_kernel() if self.kernel_manager: self.kernel_manager.stop_restarter() self.spyder_kernel_comm.close() if self.kernel_client is not None: self.kernel_client.stop_channels() if self.kernel_manager: shutdown_thread = QThread(None) shutdown_thread.kernel_manager = self.kernel_manager shutdown_thread.run = self.shutdown_kernel self.shutdown_thread_list.append(shutdown_thread) shutdown_thread.start() else: self.spyder_kernel_comm.close(shutdown_channel=False) if self.kernel_client is not None: self.kernel_client.stop_channels() self.prune_shutdown_thread_list() super(ShellWidget, self).shutdown()
def __init__(self, parent=None, worker: QObject = None): super().__init__(parent) self.thread_recv = QThread() self.worker_recv = worker self.worker_recv.moveToThread(self.thread_recv) self.thread_recv.started.connect(self.worker_recv.work) self.thread_recv.start() self.thread_recv.finished.connect(self.signal_finished.emit)
def __init__(self, callback, milis): super().__init__() self.milis = milis self.signal.connect(callback) self.thread = QThread() self.timer = QTimer() #self.timer.timeout.connect(self.timeout) #self.timer.start(milis) self.thread.started.connect(self.init)
def __init__(self, parent=None, worker: QObject = None): super().__init__(parent) self.thread = QThread() self.worker = worker self.worker.moveToThread(self.thread) self.thread.started.connect(self.worker.work) # self.worker_recv.work) self.thread.finished.connect(self.worker.deleteLater) self.thread.finished.connect(self.thread.deleteLater) self.thread.start()
def addAlgorithm(self, algorithm): algorithm_thread = QThread() algorithm.setDiskSize(self.disk_size) algorithm.moveToThread(algorithm_thread) algorithm_thread.started.connect(algorithm.run) self.algorithms.append(algorithm) self.threads.append(algorithm_thread) self.update()
def set_worker(self, worker): """"Install the provided worker on this manager""" self._worker = worker self._thread = QThread() self._worker.moveToThread(self._thread) self._thread.started.connect(self._worker.run_tasks) # Connect the worker signals to handlers. self._worker.sig_task_completed.connect(self._exec_task_callback)
def play_video(self, artist: str, title: str, start_time: float) -> None: """ Slot used to play a video. This is called when the API is first initialized from this GUI, and afterwards from the event loop handler whenever a new song is detected. If an error was detected when downloading the video, the default one is shown instead. """ # Checking that the artist and title are valid first of all if self.api.artist in (None, '') and self.api.title in (None, ''): logging.info("The provided artist and title are empty.") self.on_youtubedl_fail() return # This delay is used to know the elapsed time until the video # actually starts playing, used in the audiosync feature. self.timestamp = start_time # Loading the audio synchronization feature before anything else query = f"ytsearch:{format_name(artist, title)} Official Video" if self.config.audiosync: # First trying to stop the previous audiosync thread, as only # one audiosync thread can be running at once. If it wasn't # initialized, the worker is created. try: # Although inheriting from QThread and reusing the same object # may not be the standard, QThread.start() is guaranteed to # work once QThread.run() has returned. Thus, this will wait # until it's done and launch the new one. logging.info("Stopping the previous audiosync thread") self.audiosync.abort() self.audiosync.wait() except AttributeError: logging.info("Creating a new audiosync thread") from vidify.audiosync import AudiosyncWorker self.audiosync = AudiosyncWorker() self.audiosync.success.connect(self.on_audiosync_success) self.audiosync.failed.connect(self.on_audiosync_fail) logging.info("Starting the audiosync thread") self.audiosync.youtube_title = query self.audiosync.start() # Launching the thread with YouTube-DL to obtain the video URL # without blocking the GUI. logging.info("Starting the youtube-dl thread") self.youtubedl = YouTubeDLWorker(query, self.config.debug, self.config.width, self.config.height) self.yt_thread = QThread() self.youtubedl.moveToThread(self.yt_thread) self.yt_thread.started.connect(self.youtubedl.get_url) self.youtubedl.success.connect(self.on_yt_success) self.youtubedl.fail.connect(self.on_youtubedl_fail) self.youtubedl.finish.connect(self.yt_thread.exit) self.yt_thread.start()
def __init__(self, parent, device, ctrls, names, is_orb, prefix='', acc='SI'): """.""" super(BaseWidget, self).__init__(parent) self.setObjectName(acc.upper() + 'App') self.EXT = f'.{acc.lower()}dorb' self.EXT_FLT = f'Sirius Delta Orbit Files (*.{acc.lower()}dorb)' self.line_names = names self.prefix = prefix self.device = _PVName(device) self.devpref = self.device.substitute(prefix=prefix) self.controls = ctrls self._csorb = SOFBFactory.create(acc) self.update_rate = 2.1 # Hz self.last_dir = self.DEFAULT_DIR self.is_orb = is_orb self.timer = QTimer() self.thread = QThread() self.updater = [] self.graph = {'x': None, 'y': None} for _ in range(2): upd = UpdateGraph(ctrls, is_orb, acc) upd.moveToThread(self.thread) self.timer.timeout.connect(upd.update_graphic) self.updater.append(upd) self.setupui() self.connect_signals() prefx, prefy = ('BPMX', 'BPMY') if self.is_orb else ('CH', 'CV') self.enbl_pvs = { 'x': _ConnSig(self.devpref.substitute(propty=prefx + 'EnblList-RB')), 'y': _ConnSig(self.devpref.substitute(propty=prefy + 'EnblList-RB')) } for pln, signal in self.enbl_pvs.items(): sig = signal.new_value_signal[_np.ndarray] for upd in self.updater: sig.connect(_part(upd.set_enbl_list, pln)) self.enbl_pvs_set = { 'x': _ConnSig(self.devpref.substitute(propty=prefx + 'EnblList-SP')), 'y': _ConnSig(self.devpref.substitute(propty=prefy + 'EnblList-SP')) } self.thread.start() self.timer.start(1000 / self.update_rate)
def on_runloop_clicked(self): if not self.primaryThreadCreated: if not self.workerThreadCreated: self.worker = WorkerThread(self.s, self.generator) self.workerThread = QThread() self.workerThread.started.connect(self.worker.run) self.worker.signal.connect(self.write_info) self.worker.moveToThread(self.workerThread) self.workerThread.start() self.workerThreadCreated = True print("Starting Worker Thread")
def shutdown(self): """Shutdown kernel""" if self.get_kernel() is not None and not self.slave: self.shellwidget.spyder_kernel_comm.close() self.shellwidget.spyder_kernel_comm.shutdown_comm_channel() self.shellwidget._pdb_history_file.save_thread.stop() self.shellwidget.kernel_manager.stop_restarter() self.shutdown_thread = QThread() self.shutdown_thread.run = self.finalize_shutdown self.shutdown_thread.finished.connect(self.stop_kernel_channels) self.shutdown_thread.start()
def __init__(self, address: Tuple[str, int], parent=None): super().__init__(parent) self.dispatcher_dic = {} self.long_conn_sockets: Dict[str, socket.socket] = {} self.socket = init_socket(address) self.server_loop_thread = QThread() self.loop_worker = LoopWork(self, self.socket) self.loop_worker.moveToThread(self.server_loop_thread) self.server_loop_thread.started.connect(self.loop_worker.work) self.server_loop_thread.start()
def __init__(self, parent): QObject.__init__(self, parent) self.endpoint = None self.requests = {} self.languages = [] self.mutex = QMutex() self.opened_files = {} self.thread_started = False self.thread = QThread() self.moveToThread(self.thread) self.thread.started.connect(self.started) self.sig_perform_request.connect(self.perform_request)
def __init__(self, parent): QObject.__init__(self) self.stopped = False self.daemon = True self.mutex = QMutex() self.language_snippets = {} self.thread = QThread() self.moveToThread(self.thread) self.thread.started.connect(self.started) self.sig_mailbox.connect(self.handle_msg) self.sig_update_snippets.connect(self.update_snippets)
def on_btninit_clicked(self): if not self.workerThreadCreated: if not self.primaryThreadCreated: self.primary = PrimaryThread(self.s, self.generator) self.primaryThread = QThread() self.primaryThread.started.connect(self.primary.run) self.primary.signal.connect(self.write_info) self.primary.moveToThread(self.primaryThread) self.primaryThread.start() self.primaryThreadCreated = True print("Starting Primary Thread") if self.serialSensorOpen: if not self.sensorThreadCreated: self.sensor = SensorThread(self.s2) self.sensorThread = QThread() self.sensorThread.started.connect(self.sensor.run) self.sensor.signal.connect(self.sensorData) self.sensor.moveToThread(self.sensorThread) self.sensorThread.start() self.sensorThreadCreated = True print("Starting Sensor Thread ...")
def _init_thread(self): self._thread = QThread() self._worker = FileUpdateWorker(self._file) self._worker.moveToThread(self._thread) self._worker.read.connect(self._model.append_text) self._thread.started.connect(self._worker.setup) self._thread.finished.connect(self._worker.stop) self._thread.finished.connect(self._worker.deleteLater) self.finished.connect(self._stop_thread) self._thread.start()
def __init__(self, parent): QObject.__init__(self) self.stopped = False self.daemon = True self.mutex = QMutex() self.file_tokens = {} self.diff_patch = diff_match_patch() self.thread = QThread() self.moveToThread(self.thread) self.thread.started.connect(self.started) self.sig_mailbox.connect(self.handle_msg)
def __init__(self, parent=None, name='Anonymous QtClient'): super().__init__(parent) self.name = name self.client = self.init_socket(12306) self.thread_recv = QThread() self.worker_recv = RecvWork(self.client, self.name) self.signal_received = self.worker_recv.signal_received self.worker_recv.signal_received.connect(self.on_server_message_received) self.worker_recv.moveToThread(self.thread_recv) self.thread_recv.started.connect(self.worker_recv.work) self.thread_recv.start()
def shutdown(self): """Shutdown kernel""" self.shutdown_called = True self.spyder_kernel_comm.close() self.spyder_kernel_comm.shutdown_comm_channel() self.kernel_manager.stop_restarter() self.shutdown_thread = QThread() self.shutdown_thread.run = self.kernel_manager.shutdown_kernel if self.kernel_client is not None: self.shutdown_thread.finished.connect( self.kernel_client.stop_channels) self.shutdown_thread.start()
def on_btnHoming_clicked(self): self.setState(self.stateHoming) self._thread = QThread() self._runner = HomingRunner(self.currentServo(), self._ENABLE_TIMEOUT, self._HOMING_TIMEOUT) self._runner.moveToThread(self._thread) self._thread.started.connect(self._runner.run) self._runner.finished.connect(self.onHomingFinished) self._runner.finished.connect(self._thread.quit) self._runner.finished.connect(self._runner.deleteLater) self._thread.finished.connect(self._thread.deleteLater) self._thread.start()
def onTimerExpired(self): """Triggers the updater on each timer expiration.""" self._thread = QThread() self._updater = RegisterUpdater(self._servo, self._watched, self._base_period) self._updater.moveToThread(self._thread) self._thread.started.connect(self._updater.update) self._updater.finished.connect(self.onUpdaterFinished) self._updater.finished.connect(self._thread.quit) self._updater.finished.connect(self._updater.deleteLater) self._thread.finished.connect(self._thread.deleteLater) self._thread.start()