Example #1
0
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # Some buttons
        layout = QVBoxLayout()

        self.text = QPlainTextEdit()
        layout.addWidget(self.text)

        btn_run = QPushButton("Execute")
        btn_run.clicked.connect(self.start)

        layout.addWidget(btn_run)

        w = QWidget()
        w.setLayout(layout)
        self.setCentralWidget(w)

        # Thread runner
        self.threadpool = QThreadPool()

    def start(self):

        # Create a runner
        self.runner = SubProcessWorker("python ~/dumy.py")
        self.runner.signals.result.connect(self.result)
        self.threadpool.start(self.runner)

    def result(self, s):
        self.text.appendPlainText(s)
Example #2
0
class App(QWidget):
    def __init__(self):
        super().__init__()
        self.title = 'Hello, world!'
        self.left = 2100
        self.top = 500
        self.width = 640
        self.height = 480
        self.threadpool = QThreadPool()
        self.initUI()

    def initUI(self):
        self.setWindowTitle(self.title)
        self.setGeometry(self.left, self.top, self.width, self.height)
        checkbox = QCheckBox('Check Box', self)
        checkbox.stateChanged.connect(self.clickCheckbox)
        self.show()

    def clickCheckbox(self):
        thread = Thread()
        thread.signal.return_signal.connect(self.function_thread)
        self.threadpool.start(thread)

    def function_thread(self, signal):
        print(signal)
Example #3
0
class Ui(QtWidgets.QDialog):

    def __init__(self):
        container = Container()
        super(Ui, self).__init__() # Call the inherited classes __init__ method
        uic.loadUi('./view/main.ui', self) # Load the .ui file
        self.show() # Show the GUI
        worker = Container.worker_logic()
        worker.frameSignal.result.connect(self.display_data)
        self.thread = QThreadPool()
        self.thread.start(worker)
        self.text = self.findChild(QtWidgets.QLabel, 'label')
        self.frame = self.findChild(QtWidgets.QFrame, 'frameLabel')
        self.data_input = self.findChild(QtWidgets.QLineEdit, 'inputFrame')
        self.button = self.findChild(QtWidgets.QPushButton, 'sendFrameButton')
        self.button.clicked.connect(self.sendFrame)

    def sendFrame(self):
        print('sent')
        data = self.data_input.text()
        self.thread.start(Container.send_frame_logic(data))

    @pyqtSlot(object)
    def display_data(self, data):
        print(data)
        self.text.setText(data)
Example #4
0
class Downloader(QObject):

    finished = pyqtSignal()

    def __init__(self, queue):
        """
        Class that spawns the separate download threads.  This is a separate class so it can be moved to its own thread
        and run simultaneously with post extraction.

        :param queue: The download queue in which extracted content is placed
        """
        super().__init__()
        self.queue = queue
        self.run = True

        self.settings = QSettings("SomeGuySoftware", "RedditDownloader")

        self.download_pool = QThreadPool()
        self.download_pool.setMaxThreadCount(
            self.settings.value('thread_limit', 4, type=int))

    def download(self):
        """Spawns the download pool threads"""
        while self.run:
            post = self.queue.get()
            if post is not None:
                self.download_pool.start(post)
            else:
                self.run = False
        self.download_pool.waitForDone()
        self.finished.emit()

    def stop(self):
        self.run = False
        self.download_pool.clear()
Example #5
0
def main():
    args = read_args()

    # application
    app = QApplication([])

    app.setOverrideCursor(Qt.BlankCursor)

    # main window
    window = MainWindow(
        {
            'green': ROOT / 'bg_green.png',
            'red': ROOT / 'bg_red.png'
        },
        fullscreen=True,
        debug=False,
        size=app.desktop().screenGeometry().size())
    try:
        window.set_power(not args.poweroff)
        window.set_color(args.color)
        window.set_background(args.background)
    except BaseException:
        logging.exception('Failed to exec args')

    # signals
    piper = Piper()
    window.connect_signals(piper.signals)
    pool = QThreadPool()
    pool.start(piper)
    try:
        app.exec()
    except KeyboardInterrupt:
        print('Keyboard interrupt', flush=True)
    finally:
        print('quitting', flush=True)
Example #6
0
class SpeedSlider(QSlider):
    def __init__(self, geo, object_name, value, max, parent):
        super().__init__(Qt.Vertical, parent)
        self.speed = 50
        self.light = parent.light
        self.strobe_worker = StrobeWorker(self.light, 50, self)
        self.thread_pool = QThreadPool()
        self.setObjectName(object_name)
        self.setGeometry(geo[0], geo[1], geo[2], geo[3])
        self.setValue(value)
        self.setMaximum(max)
        self.valueChanged[int].connect(self.strobe)

    def strobe(self, value):
        try:
            value = 50 - value
            if self.speed == 50 and value < 50:
                self.strobe_worker = StrobeWorker(self.light, value, self)
                self.thread_pool.start(self.strobe_worker)
            self.speed = value
            self.strobe_worker.change_speed(value)
        except (GenericHueError, UnauthorizedUserError) as e:
            self.connection_handler.update_status(str(e), True)
        except DeviceIsOffError:  # Don't care if device is off, just don't take any action
            pass
Example #7
0
class appWin(QMainWindow):
    def __init__(self):
        super(appWin, self).__init__()
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.threadpool = QThreadPool()
        print('Multithreading with maximum {} thread'.format(
            self.threadpool.maxThreadCount()))

        self.timer = QTimer()
        self.timer.setInterval(0.1)
        self.timer.timeout.connect(self.on_timer_timeout)
        self.timer.start()
        self.count = 0

        self.ui.pushButton.clicked.connect(self.on_btn)

    def on_timer_timeout(self):
        self.count += 1
        self.ui.label.setText(str(self.count))

    def on_btn(self):
        # for i in range(5):
        #     # QApplication.processEvents()
        #     self.ui.label_2.setText(str(i+1))
        #     time.sleep(1)
        worker1 = Worker([1, 2, 3, 4], 'Ali', ui=self.ui, test='pp')
        self.threadpool.start(worker1)
Example #8
0
class AsyncPoolController(AsyncAbstractController):
    def __init__(
            self,
            # A number *n* to create a pool of *n* simple threads, where each thread
            # lacks an event loop, so that it can emit but not receive signals.
            # This means that ``g`` may **not** be run in a thread of this pool,
            # without manually adding a event loop. If *n* < 1, the global thread pool
            # is used.
            maxThreadCount,

            # |parent|
            parent=None):

        super(AsyncPoolController, self).__init__(parent)
        if maxThreadCount < 1:
            self.threadPool = QThreadPool.globalInstance()
        else:
            self.threadPool = QThreadPool()
            self.threadPool.setMaxThreadCount(maxThreadCount)

    # |_start|
    def _start(self, future):
        # Asynchronously invoke ``f``.
        apw = _AsyncPoolWorker(future)
        self.threadPool.start(apw)

    # |terminate|
    def _terminate(self):
        self.threadPool.waitForDone()
        del self.threadPool
Example #9
0
class LiveFlight():
    def __init__(self):
        pass

    def run(self):
        self.app = QApplication(sys.argv)
        self.mm = MemoryManager()
        self.mm.dm.data_processor.set_structure(self.mm.conf['new_structure'])
        # Logic threads
        self.threadpool = QThreadPool()
        self.log = LiveFlightLogic(self)
        self.gui = LiveFlightGui(self)
        self.af = AdditionalThread(self)
        self.af.port_dialog_signal.connect(self.open_port_dialog)
        self.af.start()
        # main window
        self.main_window = MainWindow()
        self.main_window.show()
        # running it
        self.threadpool.start(self.log)
        self.threadpool.start(self.gui)
        self.app.exec_()

    def open_port_dialog(self, args):
        def dialog_callback(self, args):
            ans = self.dialog.ans
            self.dialog.close()
            self.mm.dyn['port'] = ans
            args['callback']()
        self.dialog = PortSetWindow(self.main_window)
        self.dialog.set_port(args['ports'])
        ans = None
        self.dialog.value_changed_signal.connect(
        lambda: dialog_callback(self, args))
        self.dialog.exec_()
Example #10
0
class LockWindow(QtWidgets.QWidget):
    def __init__(self):
        super(LockWindow, self).__init__()
        self.create_UI()
        self.threadpool = QThreadPool()


    def unlock(self):
        self.start_button.setEnabled(False)
        rec_thread = FaceRecognitionThread()
        rec_thread.signals.finished.connect(self.update_UI)

        self.threadpool.start(rec_thread)

    def update_UI(self):
        self.descr_label.setText("Hi, nice to see you again! UNLOCKED")

    def create_UI(self):
        self.start_button = QPushButton("Start")
        self.start_button.clicked.connect(self.unlock)
        self.descr_label = QLabel("Place your face in front of your camera.")
        self.descr_label.setAlignment(Qt.AlignCenter)
        vbox = QVBoxLayout()
        vbox.addWidget(self.descr_label)
        vbox.addWidget(self.start_button)

        self.setLayout(vbox)
        self.showFullScreen()
class FatContentExporter(QDialog):
    progress_signal = pyqtSignal(tuple)

    def __init__(self, parent, dest_dir: str, selected_album: AlbumData, images: []):
        super().__init__(parent)
        self.setWindowFlag(Qt.WindowCloseButtonHint, False)
        self.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
        self.setWindowTitle('Album Content Exporter')
        self.setWindowIcon(QIcon(QPixmap(QImageReader('assets/exportAlbumContent.png').read())))

        # Layout setup
        layout = QVBoxLayout()
        layout.addWidget(QLabel('Exporting album files...'))
        self.progress = QProgressBar()
        self.progress.setValue(0)
        self.progress.setFormat('Waiting (%p%)')
        layout.addWidget(self.progress)
        self.current_file = QLabel('Waiting...')
        layout.addWidget(self.current_file)
        layout.addStretch()

        # Init thread
        self.progress_signal.connect(self.update_progress)
        self.thread_pool = QThreadPool()
        self.thread_worker = Worker(self.run)
        self.thread_worker.signals.progress.connect(self.progress_signal)
        self.thread_worker.signals.finished.connect(self.update_after_completion)

        self.images = images
        self.selected_album = selected_album
        self.dest_dir = dest_dir

        self.setLayout(layout)
        self.setFixedSize(300, 80)
        self.thread_pool.start(self.thread_worker)
        self.exec()

    def update_after_completion(self):
        self.hide()

    def update_progress(self, status: tuple):
        if status[0] is 'COLLECTING':
            self.progress.setFormat('Collecting (%p%)')
        else:
            self.progress.setFormat('Saving (%p%)')
        self.progress.setValue(status[1] + 1)
        self.current_file.setText(status[2])

    def run(self, signal):
        self.progress.setMaximum(len(self.images) - 1)
        images = []
        for cap_img in self.images:
            images.append(FatPhoto(cv2.imread(cap_img.get_image(), cv2.IMREAD_UNCHANGED),
                                   basename(cap_img.get_image())))
            signal.emit(('COLLECTING', self.images.index(cap_img), cap_img.get_name()))
        fat_data = FatAlbumData(self.selected_album.get_title(), self.selected_album.get_description(), images)

        signal.emit(('SAVING', -1, fat_data.get_title() + '.jfatalbum'))
        self.progress.setMaximum(0)
        pickle.dump(fat_data, open(join(self.dest_dir, fat_data.get_title() + '.jfatalbum'), 'wb'), 4)
class SSRInstallDialog(QDialog, Ui_SSRInstallDialog):
    def __init__(self, *args, path, **kwargs):
        super(SSRInstallDialog, self).__init__(*args, **kwargs)
        self.setupUi(self)
        self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
        self.threadPool = QThreadPool(parent=self)
        self.path = path
        self.installThread = SSRInstallThread(self.path)
        self.installThread.signals.stderr.connect(self.display_stderr)
        self.installThread.signals.stdout.connect(self.display_stdout)
        self.installThread.signals.done.connect(self.finalize)
        self.threadPool.start(self.installThread)

    def display_stderr(self, text):
        self.textEdit.moveCursor(QTextCursor.End)
        cursor = self.textEdit.textCursor()
        fmt = cursor.charFormat()
        fmt.setForeground(QtCore.Qt.red)
        cursor.setCharFormat(fmt)
        cursor.insertText(text)

    def display_stdout(self, text):
        self.textEdit.moveCursor(QTextCursor.End)
        cursor = self.textEdit.textCursor()
        fmt = cursor.charFormat()
        fmt.setForeground(QtCore.Qt.black)
        cursor.setCharFormat(fmt)
        cursor.insertText(text)

    def finalize(self):
        self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(True)
Example #13
0
class AsyncPoolController(_AsyncAbstractController):
    def __init__(self,
      # A number *n* to create a pool of *n* simple threads, where each thread
      # lacks an event loop, so that it can emit but not receive signals.
      # This means that g_ may **not** be run in a thread of this pool,
      # without manually adding a event loop. If *n* < 1, the global thread
      # pool is used.
      maxThreadCount,

      # See parent_.
      parent=None):

        super().__init__(parent)
        if maxThreadCount < 1:
            self.threadPool = QThreadPool.globalInstance()
        else:
            self.threadPool = QThreadPool(self)
            self.threadPool.setMaxThreadCount(maxThreadCount)

    # See `_start`_.
    def _start(self, future):
        # Asynchronously invoke f_.
        apw = _AsyncPoolWorker(future)
        self.threadPool.start(apw)

    # See `_terminate`_.
    def _terminate(self):
        self.threadPool.waitForDone()
        del self.threadPool
Example #14
0
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # Some buttons
        w = QWidget()
        l = QHBoxLayout()
        w.setLayout(l)

        btn_stop = QPushButton("Stop")
        l.addWidget(btn_stop)

        # Create a statusbar.
        self.status = self.statusBar()
        self.progress = QProgressBar()
        self.status.addPermanentWidget(self.progress)

        # Thread runner
        self.threadpool = QThreadPool()

        # Create a runner
        self.runner = JobRunner()
        self.runner.signals.progress.connect(self.update_progress)
        self.threadpool.start(self.runner)

        btn_stop.pressed.connect(self.runner.kill)

        self.setCentralWidget(w)

    def update_progress(self, n):
        self.progress.setValue(n)
Example #15
0
class ThreadingApi:
    """API for scheduling background tasks."""
    def __init__(self, log_api: LogApi) -> None:
        """Initialize self.

        :param log_api: logging API
        """
        self._log_api = log_api
        self._thread_pool = QThreadPool()

    def schedule_task(
        self,
        function: Callable[..., Any],
        complete_callback: Callable[..., Any],
    ) -> None:
        """Schedule a task to run in the background thread pool.

        :param function: function to run
        :param complete_callback:
            callback to execute when the function finishes
            (executed in the qt thread)
        """
        worker = OneShotWorker(self._log_api, function)
        worker.signals.finished.connect(complete_callback)
        self._thread_pool.start(worker)

    def schedule_runnable(self, runnable: QRunnable) -> None:
        """Schedule a QRunnable to run in the background thread pool.

        :param runnable: QRunnable to schedule
        """
        self._thread_pool.start(runnable)
Example #16
0
class MainWindow(QtWidgets.QMainWindow):
    def __init__(self):
        super().__init__(flags=Qt.CustomizeWindowHint
                         | Qt.WindowMinimizeButtonHint
                         | Qt.WindowCloseButtonHint)
        vlayout = QtWidgets.QVBoxLayout()
        widget = QtWidgets.QWidget()
        widget.setLayout(vlayout)
        self.setCentralWidget(widget)
        self.bar = QtWidgets.QProgressBar()
        self.bar.setMinimum(0)
        self.bar.setMaximum(MAX_ITER)
        self.bar.setValue(0)
        vlayout.addWidget(self.bar)
        self.button = QtWidgets.QPushButton("Start")
        self.button.pressed.connect(self.process)
        vlayout.addWidget(self.button)
        button = QtWidgets.QPushButton("About")
        button.pressed.connect(app.aboutQt)
        vlayout.addWidget(button)
        self.thread_pool = QThreadPool(self)
        self.destroyed.connect(lambda: self.cleanup())

    def process(self):
        processor = Processor(self)
        processor.signals.iteration_passed.connect(self.bar.setValue,
                                                   Qt.DirectConnection)
        processor.signals.status_changed.connect(self.button.setDisabled)
        processor.signals.finished.connect(lambda: self.bar.setValue(0))
        self.thread_pool.start(processor)

    def cleanup(self):
        self.thread_pool.waitForDone()
class PROCESS(QObject):
    queue_finished = pyqtSignal(int)
    prog_finished = pyqtSignal(tuple)
    stoped = pyqtSignal(int, int)  # 1: start, 0: finished, 2: error | queue
    state = pyqtSignal(int, str)

    def __init__(self, parent=None):
        QObject.__init__(self, parent)
        self.process = QProcess()
        self.process.setProcessChannelMode(QProcess.MergedChannels)
        self.process.finished.connect(self.emit_finished)
        self.process.stateChanged.connect(self.emit_state)
        self.process_type = 0  # 0 process, 1 runnable
        self.threadpool = QThreadPool()
        self.worker = Worker()
        self.worker.signals.state.connect(self.emit_state)
        self.queue = None

    def emit_state(self, state):
        self.state.emit(state, self.prog_name)

    def emit_finished(self, exitcode, exitstatus):
        self.prog_finished.emit((self.prog_name, exitcode, exitstatus))

    def set_queue(self, queue):
        self.queue = queue

    def start_process(self):
        try:
            obj = self.queue.get(False)
            self.prog_name = list(obj.keys())[0]
            if callable(list(obj.values())[0][0]):
                self.process_type = 1
                funct = list(obj.values())[0][0]
                args = list(obj.values())[0][1]
                self.worker.insert_function(funct, args, self.prog_name)
                self.threadpool.start(self.worker)
            else:
                self.process_type = 0
                self.process.start(
                    list(obj.values())[0][0],
                    list(obj.values())[0][1])
        except Empty:
            self.queue_finished.emit(self.queue.name)

    def force_finished(self):
        # for process (programs)
        self.stoped.emit(1, self.queue.name)
        if self.process_type == 0:
            self.process.terminate()
            if not self.process.waitForFinished(1000):
                self.process.kill()
        else:
            if self.threadpool.activeThreadCount():
                self.threadpool.clear()
                self.threadpool.waitForDone()
        with self.queue.mutex:
            self.queue.queue.clear()
        self.stoped.emit(0, self.queue.name)
Example #18
0
class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()
        self.setupUi(self)

        for country in LOCATION.keys():
            self.comboBoxCountry.addItem(country)
        for city in LOCATION[self.comboBoxCountry.currentText()]:
            self.comboBoxCity.addItem(city)

        self.comboBoxCountry.currentTextChanged.connect(self.set_city)
        self.pushButton.pressed.connect(self.update_weather)

        self.threadpool = QThreadPool()
        self.show()

    def set_city(self, country):
        self.comboBoxCity.clear()
        for city in LOCATION[country]:
            self.comboBoxCity.addItem(city)

    def update_weather(self):
        location = self.comboBoxCity.currentText(
        ) + "," + self.comboBoxCountry.currentText()
        worker = WeatherWorker(location)
        worker.signals.result.connect(self.weather_result)
        worker.signals.error.connect(self.alert)
        self.threadpool.start(worker)

    def alert(self, message):
        QMessageBox.warning(self, "Warning", message)

    def weather_result(self, weather, forecasts):
        self.latitudeLabel.setText("%.2f °" % weather['coord']['lat'])
        self.longitudeLabel.setText("%.2f °" % weather['coord']['lon'])

        self.windLabel.setText("%.2f m/s" % weather['wind']['speed'])

        self.temperatureLabel.setText("%.1f °C" % weather['main']['temp'])
        self.pressureLabel.setText("%d" % weather['main']['pressure'])
        self.humidityLabel.setText("%d" % weather['main']['humidity'])

        self.weatherLabel.setText("%s (%s)" %
                                  (weather['weather'][0]['main'],
                                   weather['weather'][0]['description']))

        self.set_weather_icon(self.weatherIcon, weather['weather'])

        for n, forecast in enumerate(forecasts['list'][:5], 1):
            getattr(self, 'forecastTime%d' % n).setText(
                from_ts_to_time_of_day(forecast['dt']))
            self.set_weather_icon(getattr(self, 'forecastIcon%d' % n),
                                  forecast['weather'])
            getattr(self, 'forecastTemp%d' % n).setText(
                "%.1f °C" % forecast['main']['temp'])

    def set_weather_icon(self, label, weather):
        label.setPixmap(
            QPixmap(os.path.join('images', "%s.png" % weather[0]['icon'])))
Example #19
0
def asyncrun(function: typing.Callable,
             *args,
             pool: QThreadPool = None,
             **kwargs) -> None:
    """Run function with args and kwargs in parallel on a QThreadPool."""
    pool = pool if pool is not None else Pool.get()
    runnable = GenericRunnable(function, *args, **kwargs)
    pool.start(runnable)
Example #20
0
class LibraryTaskManager(QWidget):
    class Runner(QRunnable):
        def __init__(self, function, args):
            super().__init__()
            self.function = function
            self.args = args

        def run(self):
            self.function(*self.args)

    def __init__(self):
        super().__init__()
        self.thread_pool = QThreadPool()
        self.task_combo = QComboBox()
        self.task_combo.currentIndexChanged.connect(self.get_item_status)
        self.progress = QProgressBar()
        self.progress.setMaximum(100)
        self.timer = QTimer()
        q_size = QSize(16, 16)
        self.icon_in_progress = QIcon.fromTheme("media-playback-start")
        self.icon_completed = QIcon.fromTheme("media-playback-stop")
        self.task_combo.setIconSize(q_size)
        self.timer.timeout.connect(self.timeout)
        self.task_lookup = {}
        self._init_ui()

    def _init_ui(self):
        layout = QHBoxLayout()
        layout.setContentsMargins(0, 0, 0, 0)
        layout.addWidget(QLabel("Task Executor"))
        layout.addWidget(self.task_combo)
        layout.addWidget(self.progress)
        self.setLayout(layout)

    def execute(self, function, args):
        runner = self.Runner(function, args)
        runner.setAutoDelete(True)
        self.thread_pool.start(runner)

    def execute_with_progress(self, function, args, task_ref):
        self.execute(function, args)
        self.task_lookup[task_ref[0]] = task_ref[1]
        self.task_combo.addItem(self.icon_in_progress, task_ref[0])
        self.task_combo.setCurrentIndex(self.task_combo.findText(task_ref[0]))

    def get_item_status(self):
        self.timer.start(500)

    def timeout(self):
        task_name = self.task_combo.currentText()
        task_ref = self.task_lookup[task_name]
        print(f"status for {task_ref}")
        status = LibraryManagement.get_task_status(task_ref)
        self.progress.setValue(status['percent_complete'])
        if status['status'] == "COMPLETE":
            self.task_combo.setItemIcon(self.task_combo.findText(task_ref),
                                        self.icon_completed)
            self.timer.stop()
class MainWindow(QWidget):
    log = logging.getLogger(__name__)

    EXIT_CODE_REBOOT: int = -123456789

    def __init__(self, version: str):
        super().__init__()
        self.status = CheckVersionMessage.not_checked
        self.current_version = version

        self.wait_window = WaitWindow(f'You use the version {version}.')
        self.debug_window = QTextEditLogger()

        self.wait_window.sigUpdateClicked.connect(self._update_version)
        self.wait_window.sigRestartClicked.connect(self.restart)
        self.wait_window.sigCheckClicked.connect(self.check_version)

        self.q_thread_pool = QThreadPool()

    @pyqtSlot(object, name='setStatus')
    def _set_status(self, res: CheckVersionMessage):
        self.status = res

    @pyqtSlot(name='updateVersion')
    def _update_version(self):
        self.wait_window.on_update()
        try:
            version = self.status.version
        except AttributeError:
            version = None

        self.worker = Worker(update_version, version=version)
        self.worker.signals.result.connect(self._on_updated)
        self.q_thread_pool.start(self.worker)

    @pyqtSlot(name='checkVerison')
    def check_version(self):
        self.wait_window.on_checking()

        self.worker = Worker(check_outdated, self.current_version)
        self.worker.signals.result.connect(self.wait_window.get_result)
        self.worker.signals.result.connect(self._set_status)
        self.q_thread_pool.start(self.worker)

    @pyqtSlot(object, name='onUpdatedFinished')
    def _on_updated(self, updated: bool):
        if updated:
            self.wait_window.show_restart()
        else:
            self.wait_window.show_info('Auto update failed. Please, update the program manually.')

    @pyqtSlot(name='restartApp')
    def restart(self):
        qApp = QApplication.instance()
        qApp.closeAllWindows()
        qApp.exit(self.EXIT_CODE_REBOOT)
Example #22
0
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        self.threadpool = QThreadPool()

        self.x = {}
        self.y = {}
        self.lines = {}

        layout = QVBoxLayout()
        self.graphWidget = pg.PlotWidget()
        self.graphWidget.setBackground("w")
        layout.addWidget(self.graphWidget)

        button = QPushButton("Create New Worker")
        button.pressed.connect(self.execute)

        # layout.addWidget(self.progress)
        layout.addWidget(button)

        w = QWidget()
        w.setLayout(layout)

        self.setCentralWidget(w)
    
    def execute(self):
        worker = Worker()
        worker.signals.data.connect(self.receive_data)

        # Execute
        self.threadpool.start(worker)
    
    def receive_data(self, data):
        worker_id, x, y = data

        if worker_id not in self.lines:
            self.x[worker_id] = [x]
            self.y[worker_id] = [y]

            pen = pg.mkPen(
                width=2,
                color=(
                    random.randint(100,255),
                    random.randint(100,255),
                    random.randint(100,255),
                ),
            )
            self.lines[worker_id] = self.graphWidget.plot(
                self.x[worker_id], self.y[worker_id], pen=pen
            )
            return
        self.x[worker_id].append(x)
        self.y[worker_id].append(y)

        self.lines[worker_id].setData(self.x[worker_id], self.y[worker_id])
Example #23
0
class ProgressWindow(QDialog):
    signal_loaded = QtCore.pyqtSignal(tuple)
    signal_error = QtCore.pyqtSignal(int)

    def __init__(self, *args, **kwargs):
        super(ProgressWindow, self).__init__(*args, **kwargs)

        # Setting up progress bar
        self.progress_bar = QtWidgets.QProgressBar()
        self.progress_bar.setGeometry(10, 50, 230, 20)
        self.progress_bar.setMaximum(100)

        self.setWindowTitle("Loading")
        self.setFixedSize(248, 80)

        self.text_field = QLabel("Loading")

        self.layout = QVBoxLayout()
        self.layout.addWidget(self.text_field)
        self.layout.addWidget(self.progress_bar)
        self.setLayout(self.layout)

        self.threadpool = QThreadPool()
        self.interrupt_flag = threading.Event()

    def start_loading(self, selected_files):
        image_loader = ImageLoader(selected_files)

        worker = Worker(image_loader.load, self.interrupt_flag)
        worker.signals.result.connect(self.on_finish)
        worker.signals.error.connect(self.on_error)
        worker.signals.progress.connect(self.update_progress)

        self.threadpool.start(worker)

    def on_finish(self, results):
        self.update_progress(("Initalizing patient window...", 90))
        self.signal_loaded.emit((results, self))

    def update_progress(self, progress_update):
        """
        Function responsible for updating the bar percentage and the label.
        :param progress_update: A tuple containing update text and update percentage
        """
        self.text_field.setText(progress_update[0])
        self.progress_bar.setValue(progress_update[1])

    def on_error(self, err):
        if type(err[1]) is ImageLoading.NotRTSetError:
            self.signal_error.emit(0)
        elif type(err[1]) is ImageLoading.NotAllowedClassError:
            self.signal_error.emit(1)

    def closeEvent(self, event: QtGui.QCloseEvent) -> None:
        self.interrupt_flag.set()
class GenerateDocWidget(QWidget):
    def __init__(self, app):
        super().__init__()
        self.app = app
        self.threadpool = QThreadPool()
        self.images = None
        self.init_ui()

    def init_ui(self):
        self.setWindowTitle("Generowanie dokumentu w toku...")

        self.layout = QVBoxLayout()

        self.label = QLabel()
        self.movie = QMovie(os.path.join("resources", "waiting.gif"))
        self.movie.start()
        self.label.setMovie(self.movie)
        self.layout.addWidget(self.label)

        self.progressbar = QProgressBar()
        self.layout.addWidget(self.progressbar)

        self.textedit = QTextEdit()
        self.textedit.setEnabled(False)
        self.layout.addWidget(self.textedit)
        self.setLayout(self.layout)

    def start(self, settings):
        self.images = list(self.app.workspace_structures.keys())
        worker = Worker(self.generate_doc, settings=settings)
        worker.signals.result.connect(self.on_document_ready)
        worker.signals.progress.connect(self.on_progress)
        self.threadpool.start(worker)

    def generate_doc(self, progress_callback, settings):
        print(settings)
        return generate_doc(self.app.workspace_path,
                            self.app.workspace_structures, settings,
                            progress_callback)

    def on_progress(self, imagename):
        self.textedit.append("Przygotowuję {}...".format(imagename))
        self.progressbar.setValue(100.0 *
                                  float(self.images.index(imagename) + 1) /
                                  float(len(self.images)))
        print("on progress:", imagename)

    def on_document_ready(self, document):
        self.hide()
        document_path = QFileDialog.getSaveFileName(
            None, "Zapisz dokument", "oznaczone struktury.docx",
            "docx (*.docx)")
        if document_path[0] != "":
            document.save(document_path[0])
        self.close()
Example #25
0
class recordWindow(Ui_recordDialog):
    def __init__(self, Dialog):
        super(recordWindow, self).setupUi(Dialog)

    def setupUiRecord(self, Dialog):
        self.quitButton.clicked.connect(Dialog.reject)
        self.chooseButton.clicked.connect(self.getDirectory)
        self.recStopButton.clicked.connect(self.runRecStop)
        self.stringPath = ''

    def getDirectory(self):
        chosenPath = str(
            QFileDialog.getExistingDirectory(cpsMainWindow,
                                             caption="Select Directory"))
        if chosenPath != "":
            self.pathBrowser.setText(chosenPath)
            self.stringPath = chosenPath

    def thread_complete(self):
        self.recStopButton.setEnabled(True)
        self.recStopButton.setText('Record')
        self.quitButton.setEnabled(True)

    def thread_progress(self, i):
        self.recStopButton.setText(str(i) + 's')

    def runRecStop(self):
        if self.stringPath != '' and self.filenameInput.text() != '':

            self.threadpool = QThreadPool()
            input = self.filenameInput.text()
            input = input.split('.', 1)[0]

            self.recStopButton.setEnabled(False)
            self.quitButton.setEnabled(False)

            self.threadRecord = QThread()
            self.threadTime = QThread()
            self.workerRecord = workerRecord(self.lengthSpinBox.value(), input)
            self.workerTime = workerTime(self.lengthSpinBox.value())

            self.workerRecord.signals.finished.connect(self.thread_complete)
            self.workerRecord.signals.finished.connect(
                self.threadRecord.deleteLater)
            self.workerRecord.signals.finished.connect(
                self.workerRecord.signals.deleteLater)
            self.workerTime.signals.finished.connect(self.thread_complete)
            self.workerTime.signals.finished.connect(
                self.threadTime.deleteLater)
            self.workerTime.signals.finished.connect(
                self.workerTime.signals.deleteLater)
            self.workerTime.signals.progress.connect(self.thread_progress)

            self.threadpool.start(self.workerRecord)
            self.threadpool.start(self.workerTime)
Example #26
0
class LiveGraph(Canvas):
    def __init__(self):
        self.axes = [None]  # correction only for one plot with subplots
        self.fig, self.axes[0] = plt.subplots(1)

        Canvas.__init__(self, self.fig)
        Canvas.setSizePolicy(self, QtWidgets.QSizePolicy.Expanding,
                             QtWidgets.QSizePolicy.Expanding)
        Canvas.updateGeometry(self)

        self.x = []
        self.y = []

        self.running = None
        self.line = None

        self.graphWorker = Worker(self.liveGraphThread)
        self.threadPool = QThreadPool()

        self.initGraph()

    def initGraph(self):
        self.line, = self.axes[0].plot(self.x,
                                       self.y,
                                       color='b',
                                       linestyle='',
                                       marker='o',
                                       markersize='8')
        self.axes[0].set_ylim(0, 1)
        self.axes[0].set_xlim(0, 10)
        self.draw()

    def start(self):
        self.running = True
        self.threadPool.start(self.graphWorker)

    def liveGraphThread(
        self,
        statusSignal=None
    ):  # statusSignal argument required for threaded functions
        """
        Simple random graph
        (Use a Queue object from multiprocessing to handle external data flow inside this thread)
        """
        self.line.set_xdata(np.arange(0, 11))

        while True:
            if self.running:
                self.line.set_ydata(np.random.rand(11))
                self.draw()
                time.sleep(0.1)

    def stop(self):
        self.running = False
Example #27
0
    def __init__(self):
        super().__init__()

        task = Task()

        QThreadPool.globalInstance().setMaxThreadCount(5)

        #QThreadPool.globalInstance().start(Task())

        threadpool = QThreadPool(self)
        threadpool.start(Task())
Example #28
0
class LivePlot(QtWidgets.QWidget):
    '''
    A basic PyQt Widget for plotting live data received from Mantis

    Data handling is done by a new thread using the Worker Class,
    as otherwise the UI freezes and doesn't update the plot.
    '''
    def __init__(self):
        super().__init__()
        self.w = QtGui.QWidget()

        # Plot Widgets
        self.plotWidget = pg.PlotWidget()
        self.plotWidget2 = pg.PlotWidget()

        # Plot objects
        self.trace = self.plotWidget.plot()
        self.avgTrace = self.plotWidget.plot(pen='c')
        self.stats = self.plotWidget2.plot(pen='r',
                                           symbol='o',
                                           symbolPen='r',
                                           symbolBrush='r')

        # Add data properties to plot objects to store data
        self.stats.data = []

        # Button for initiating sockets with Mantis
        self.commsButton = QtWidgets.QPushButton('Start Mantis Comms', self)
        self.commsButton.clicked.connect(self.startPlot)

        # UI layout
        self.layout = QtGui.QGridLayout()
        self.w.setLayout(self.layout)
        self.layout.addWidget(self.plotWidget)
        self.layout.addWidget(self.plotWidget2)
        self.layout.addWidget(self.commsButton)
        self.w.show()

        # Ininiate the thread pool
        self.threadpool = QThreadPool()
        print("Multithreading with maximum %d threads" %
              self.threadpool.maxThreadCount())

    @pyqtSlot()
    def startPlot(self):
        '''
        Slot for sockets the initiation button
        '''
        worker = Worker(mantisComms, plotLiveData, [self.trace, self.stats])
        self.threadpool.start(worker)
        print('push')

    def testFunc(self):
        print("test")
Example #29
0
class Thread:
    def __init__(self):
        self.threadpool = QThreadPool()

    def make_worker(self, fn, *args, **kwargs) -> Worker:
        return Worker(fn, *args, **kwargs)

    def connect_sig(self, worker: Worker, signal, fn):
        worker.sig[signal].connect(fn)

    def start(self, worker):
        self.threadpool.start(worker)
Example #30
0
class MyMainWindow(QtWidgets.QMainWindow, Ui_AwAI):
    def __init__(self):
        super(MyMainWindow, self).__init__()
        self.setupUi(self)
        self.buttons = [
            self.pushButton_1, self.pushButton_2, self.pushButton_3,
            self.pushButton_4, self.pushButton_5, self.pushButton_6,
            self.pushButton_7, self.pushButton_8, self.pushButton_9,
            self.pushButton_10, self.pushButton_11, self.pushButton_12
        ]

        self.thread_pool = QThreadPool()

    def run(self):
        """Create the thread pool and set the refresh function every second """
        w0 = Worker(self.game.run_game)
        self.thread_pool.start(w0)

        self.timer = QTimer()
        self.timer.setInterval(1000)
        self.timer.timeout.connect(self.refresh)
        self.timer.start()

    def play(self, pit):
        """Update the human player variable to the right value. It is the human player play function to check if the
        move is allowed."""
        print(self.game.who_is_playing())
        self.game.who_is_playing().human_player_move = pit

    def refresh(self):
        for button, pit in zip(self.buttons, self.b.board):
            self.setValue(button, pit)

        self.nbGraines1.display(self.game.player0.loft)
        self.nbGraines2.display(self.game.player1.loft)

    def setValue(self, button, value):
        button.setText(str(value))

    def new(self):
        """Create the Settings window"""
        dialog = Settings()
        dialog.exec_()

    def closeEvent(self, event):
        """To close main function proper"""
        sys.exit(0)

    def close(self):
        """To close settings"""
        self.destroy()
        sys.exit(0)
Example #31
0
File: worker.py Project: sinhnn/ssh
class MainWindow(QMainWindow):
    def __init__(self, *args, **kwargs):
        super(MainWindow, self).__init__(*args, **kwargs)

        self.counter = 0

        layout = QVBoxLayout()

        self.l = QLabel("Start")
        b = QPushButton("DANGER!")
        b.pressed.connect(self.oh_no)

        layout.addWidget(self.l)
        layout.addWidget(b)

        w = QWidget()
        w.setLayout(layout)

        self.setCentralWidget(w)

        self.show()

        self.threadpool = QThreadPool()
        print("Multithreading with maximum %d threads" %
              self.threadpool.maxThreadCount())

    def progress_fn(self, progress):
        p, m = (progress)
        print("%d%% done %s" % (p, m))

    def execute_this_fn(self, progress_callback):
        for n in range(0, 5):
            time.sleep(1)
            progress_callback.emit((n * 100 / 4, 'blabla'))
        return "Done."

    def print_output(self, s):
        print(s)

    def thread_complete(self):
        print("THREAD COMPLETE!")

    def oh_no(self):
        # Pass the function to execute
        worker = Worker(
            self.execute_this_fn
        )  # Any other args, kwargs are passed to the run function
        worker.signals.result.connect(self.print_output)
        worker.signals.finished.connect(self.thread_complete)
        worker.signals.progress.connect(self.progress_fn)
        # Execute
        self.threadpool.start(worker)