def testQThreadReceiversExtern(self):
#QThread.receivers() - Inherited protected method
obj = QThread()
self.assertEqual(obj.receivers(SIGNAL('destroyed()')), 0)
QObject.connect(obj, SIGNAL("destroyed()"), self.cb)
self.assertEqual(obj.receivers(SIGNAL("destroyed()")), 1)
def handle_start(self):
self.thread = QThread()
self.worker = Worker(self.query_list, self.ui.delaySpinBox.text())
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.thread.deleteLater)
self.worker.progress.connect(self.ui.progressBar.setValue)
self.thread.start()
self.ui.buttonFrame.setEnabled(False)
self.ui.inputFrame.setEnabled(False)
self.thread.finished.connect(self.handle_finished)
def __init__(self):
super(EvoLisaWidget, self).__init__()
self.__image = QImage('evolisa.png')
self.__thread = QThread()
self.__worker = EvoLisaWorker()
self.__worker.moveToThread(self.__thread)
self.__thread.started.connect(self.__worker.run)
self.__thread.finished.connect(self.__thread.quit)
self.__worker.progress.connect(self.__report_progress)
self.__pixmap = None
self.setWindowTitle('EvoLisa')
def __init__(self, project_id: ProjectID, parent: QObject = None):
super().__init__(parent=parent)
self.project_id = project_id
self.buffer = collections.deque()
projects_logger_handler.buffers[project_id] = self.buffer # register our buffer
self.stopped = threading.Event()
self.can_flush_log = threading.Event()
self.thread = QThread(parent=self)
self.moveToThread(self.thread)
self.thread.started.connect(self.routine)
self.thread.start()
def __init__(self, bot, item, limit, mode, max):
QThread.__init__(self)
self.api = bot.api
self.item = item
self.limit = limit
self.mode = mode
self.max = max
self.me = self.api.me()
self.db = sqlite3.connect('database', check_same_thread=False)
cursor = self.db.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS followed_users(id TEXT, screen_name TEXT)''')
self.db.commit()
self.to_follow = []
class WeatherDownloader(QObject):
downloadComplete = Signal()
downloadFailed = Signal()
def __init_(self, parent=None):
super().__init__(self, parent)
@Slot
def downloadForecast(self):
logging.info("Request to download the forecast from YR.NO")
self._thread = QThread()
self._worker = Worker()
self._worker.moveToThread(self._thread)
# setup signals-slots
self._worker.downloadComplete.connect(self.when_complete)
self._worker.downloadFailed.connect(self.when_failed)
self._thread.started(self._worker.do_work)
self._thread.finished(self._thread.deleteLater)
def when_complete(self):
logging.info("Download complete, freeing resources")
self._thread.quit()
# emit the result
self.downloadComplete.emit()
def when_failed(self):
logging.warning("Download failed, freeing resources")
self._thread.quit()
# emit the result
self.downloadFailed.emit()
def __init__(self):
QWidget.__init__(self)
layout = QVBoxLayout(self)
self.text = QPlainTextEdit()
layout.addWidget(self.text)
self.setLayout(layout)
self.ds = DataSource()
self.worker = UpdateUserWorker()
self.worker_thread = QThread()
self.worker_thread.started.connect(self.worker.run)
self.worker.finished.connect(self.worker_thread.quit)
self.worker.moveToThread(self.worker_thread)
self.worker_thread.start()
self.worker.processed.connect(self.processed)
def __init__(self, db_mngr, listener):
"""Initializes the fetcher object.
Args:
db_mngr (SpineDBManager)
listener (SpineDBEditor)
"""
super().__init__()
self._db_mngr = db_mngr
self._listener = listener
self._thread = QThread()
# NOTE: by moving this to another thread, all the slots defined below are called on that thread too
self.moveToThread(self._thread)
self._thread.start()
self.connect_signals()
def snapshot_in_bkgroud():
# Step 2: Create a QThread object
thread = QThread()
# Step 3: Create a worker object
worker = Worker()
# Step 4: Move worker to the thread
worker.moveToThread(thread)
# Step 5: Connect signals and slots
thread.started.connect(worker.run)
worker.finished.connect(thread.quit)
worker.finished.connect(worker.deleteLater)
thread.finished.connect(thread.deleteLater)
# worker.progress.connect(reportProgress)
# Step 6: Start the thread
thread.start()
def __init__(self, mainw):
super().__init__()
self.setupUi(mainw)
self.CONFIG = ''
self.template = ''
self.xlsx_rows_list = ''
self.parent = mainw
self.pushButton_open_list_and_template.clicked.connect(
self.open_xls_and_template)
self.pushButton_ask_and_send.clicked.connect(self.send_msg)
self.pushButton_cancel_send.clicked.connect(self.abort_workers)
QThread.currentThread().setObjectName(
'main') # threads can be named, useful for log output
self.__workers_done = None
self.__threads = None
class Bridge(QObject):
def __init__(self, widget, index, login, password, proxy, key):
QObject.__init__(self)
self.thread = QThread()
self.user = User(index, login, password, proxy, key)
self.user.moveToThread(self.thread)
self.init_signal_connections(widget)
self.thread.started.connect(self.user.run)
self.thread.start()
def init_signal_connections(self, widget):
self.user.signal_update_column_color.connect(widget.change_column_color)
self.user.signal_update_column_text.connect(widget.change_column_text)
self.user.signal_update_chart.connect(widget.update_chart)
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.manager = Manager(self)
self.__threadRun = QThread()
self.__threadRun.start()
self.manager.moveToThread(self.__threadRun)
self.ui.openFile_button.clicked.connect(self.openFileButtonClicked)
self.ui.start_button.clicked.connect(self.startButtonClicked)
self.startBut.connect(self.manager.startButtonClicked)
self.manager.sendMessageConsole.connect(self.setMessage)
def start(self):
if not self.arduino_process_started or not self._arduino_process_is_alive(
):
for proc in psutil.process_iter():
# check whether the process name matches
if 'arduino_monitor.py' in proc.cmdline():
proc.kill()
if os.path.exists('arduino_monitor.py'):
self.arduino_process = subprocess.Popen(
['python', 'arduino_monitor.py'])
else:
self.arduino_process = subprocess.Popen(
['Juice_Ardiuno_Monitor'])
self.arduino_process_started = True
QThread.start(self)
def start(self, app_start_ts, args):
'''
Performs application initialization and launch
@raise SystemExit
'''
logger.debug("Launching service with args (%s)...", args)
clear_old_logs(logger)
# Load configuration file
self._cfg = config.load_config()
set_max_log_size_mb(logger, max(self._cfg.max_log_size, 0.02))
if self._cfg.copies_logging:
copies_logger = logging.getLogger('copies_logger')
set_max_log_size_mb(copies_logger, max(self._cfg.max_log_size,
0.02))
if 'sync_directory' in args and args['sync_directory']:
self._cfg.set_settings(
{'sync_directory': args['sync_directory'].decode('utf-8')})
if 'wipe_internal' in args and args['wipe_internal']:
try:
wipe_internal(self._cfg.sync_directory)
except Exception as e:
logger.warning("Can't wipe internal info. Reason: %s", e)
raise SystemExit(0)
if self._cfg.tracking_address:
self._tracker = Tracker('service_stats.db',
self._cfg.sync_directory,
self._cfg.tracking_address)
init_crash_handler(self._tracker)
self._tracker_thread = QThread()
self._tracker.moveToThread(self._tracker_thread)
self._tracker_thread.started.connect(self._tracker.start.emit)
self._tracker_thread.start(QThread.IdlePriority)
else:
init_crash_handler(logger=logger)
self._worker = ApplicationWorker(self._cfg, self._tracker,
app_start_ts, args)
self._worker.exited.connect(self._on_exit, Qt.QueuedConnection)
self._worker.start_work()
self.exec_()
logger.debug("Service exiting...")
def __init__(self, db_mngr, listener, *db_maps):
"""Initializes the fetcher object.
Args:
db_mngr (SpineDBManager)
listener (DataStoreForm)
db_maps (DiffDatabaseMapping)
"""
super().__init__()
self.db_mngr = db_mngr
self.listener = listener
self.db_maps = db_maps
self._thread = QThread()
self.moveToThread(self._thread)
self._thread.start()
self.connect_signals()
def __init__(self, GUI):
"""PlotThread adds a pyqtGraph to the GUI.
input the layout object which has the addWidget method.
The method runs on a seperate thread at the moment though run is called on
its own."""
QThread.__init__(self)
self.GUI = GUI
self.signal = signals()
#setup of graphing widget
self.graphWidget = pg.ImageView()
self.graphWidget.show()
self.GUI.addWidget(self.graphWidget, 0, 0, 1, 3)
#flags & queues
self.stopped = False
def create_thread(self, socketDescriptor):
worker = Worker(socketDescriptor)
thread = QThread()
self.onWrite.connect(worker.write_message)
worker.signal.callFunc.connect(self.call_func_parent)
worker.messageReceived.connect(self.message_received)
worker.signal.getStatus.connect(self.getStatus)
worker.signal.setStatus.connect(self.setStatus)
self.signal.getStatus.connect(worker.getStatus)
thread.started.connect(worker.start)
worker.signal.updateNr.connect(self.update_nr_clients)
worker.finished.connect(self.test)
worker.moveToThread(thread)
thread.worker = worker
thread.start()
return thread
def registerThread(self):
"""
This slot shall be called from each activated nexxT thread with a direct connection.
:return:
"""
t = QThread.currentThread()
logger.internal("registering thread %s", t.objectName())
with self._lockThreadSpecific:
if not t in self._threadSpecificProfiling:
self._threadSpecificProfiling[t] = ThreadSpecificProfItem()
self._threadSpecificProfiling[t].timer = QTimer(
parent=self.sender())
self._threadSpecificProfiling[t].timer.timeout.connect(
self._generateRecord, Qt.DirectConnection)
self._threadSpecificProfiling[t].timer.setInterval(
int(ThreadSpecificProfItem.THREAD_PROFILING_PERIOD_SEC *
1e3))
self.stopTimers.connect(
self._threadSpecificProfiling[t].timer.stop)
self.startTimers.connect(
self._threadSpecificProfiling[t].timer.start)
if self._loadMonitoringEnabled:
self._threadSpecificProfiling[t].timer.start()
tmain = QCoreApplication.instance().thread()
if self._mi is None and not tmain in self._threadSpecificProfiling:
self._mi = MethodInvoker(
dict(object=self, method="registerThread", thread=tmain),
Qt.QueuedConnection)
def __init__(self, backup, item, debug=False):
QThread.__init__(self)
self.backup = backup
self.item = item
try:
self.repo = Repo(
Utils.get_backend(backup),
callback=lambda message: self.updated.emit(self.item, message),
thread_count=backup.thread_count,
compression_level=backup.compression_level,
logger=setup_logger(self.backup.name,
get_log_file_path(self.backup.name),
logging.DEBUG if debug else logging.INFO))
except Exception as e:
print(e)
self.error.emit(e)
def __init__(self, grid: MultiCircuit, options: TransientStabilityOptions,
pf_res: PowerFlowResults):
"""
TimeSeries constructor
@param grid: MultiCircuit instance
@param options: PowerFlowOptions instance
"""
QThread.__init__(self)
self.grid = grid
self.options = options
self.pf_res = pf_res
self.results = None
def __init__(self, source, *args):
QThread.__init__(self, *args)
self.source = source
self.target = Target()
def testIntConversion(self):
i = 0
h = QThread.currentThreadId()
i = 0 + int(h)
self.assertEqual(i, int(h))
def __init__(self,device='ME', tag='TAG', environment=ENV):
QThread.__init__(self)
SkelDataRec.__init__(self, device=device, tag=tag, environment=environment)
def __init__(self):
QThread.__init__(self)
