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()
