示例#1
0
def piteca_excepthook(exctype, value, tb):
    """
    A method to catch all unhandled exception during PITECA's run .
    :param exctype: the type of exception
    :param value: the message of the exception (use str(value))
    :param tb: traceback
    """

    # if not gb.should_exit_on_error:
    # # If we are on main thread but don't want to close PITECA
    #     dialog_utils.print_error(constants.UNEXPECTED_EXCEPTION_MSG[:-1] + ": " + str(value))
    #     return

    # Show user the full error value only if it is a PITECA error
    if exctype == definitions.PitecaError:
        msg = str(value.message)
    else:
        msg = constants.UNEXPECTED_EXCEPTION_MSG

    if int(QThread.currentThreadId()) == main_thread_id:
        definitions.print_in_debug(value)
        traceback.print_tb(tb)
        dialog_utils.print_error(msg + ". PITECA will be now closed")
        sys.exit()
    else:
        # The exception_occurred_sig should be defined in every thread class in PITECA
        definitions.print_in_debug(value)
        definitions.print_in_debug(exctype)
        traceback.print_tb(tb)
        QThread.currentThread().exception_occurred_sig.emit(msg)
示例#2
0
    def __init__(self, args):
        super().__init__()

        self.args = args

        self.setWindowTitle("VPilot Drive GUI")
        form_layout = QVBoxLayout()
        self.setLayout(form_layout)
        self.resize(400, 800)

        self.button_start = QPushButton()
        self.button_start.clicked.connect(self.start_thread)
        self.button_start.setText("Start")
        form_layout.addWidget(self.button_start)

        self.button_stop = QPushButton()
        self.button_stop.clicked.connect(self.abort_worker)
        self.button_stop.setText("Stop")
        self.button_stop.setDisabled(True)
        form_layout.addWidget(self.button_stop)

        # self.log = QTextEdit()
        # form_layout.addWidget(self.log)

        self.label = QLabel(self)
        # self.label.setGeometry(QRect(20, 20, 320, 160))
        self.label.resize(320, 160)

        # self.progress = QTextEdit()
        # form_layout.addWidget(self.progress)

        QThread.currentThread().setObjectName(
            'main')  # threads can be named, useful for log output
        self.__worker_done = None
        self.__thread = None
示例#3
0
    def __init__(self, parent=None):
        """
            class initialization.

            initializes the Leecher class

            Parameters
            ----------
            nothing

            Returns
            -------
            nothing

        """
        super(Leecher, self).__init__(parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        self.setup_signals()
        self.center()
        self.show()
        self.find_seeders_alive()

        self.setup_initial_screen()

        QThread.currentThread().setObjectName(
            'main')  # threads can be named, useful for log output
        self.__workers_done = None
        self.__threads = []

        self.filename_download = ''
        self.filename = ''
示例#4
0
    def __init__(self):
        super(MyWindow, self).__init__()
        self.setWindowTitle("智能识别")
        self.resize(800,450)

        self.txt_print = QTextEdit()
        self.start_btn = QPushButton()
        self.stop_btn = QPushButton()
        self.Camera_label = QLabel()
        self.wait_label = QLabel()

        # self.txt_log.setText("点击'开始‘ 开始识别")
        self.start_btn.setText("开始识别")
        self.stop_btn.setText("停止识别")
        self.stop_btn.setDisabled(True)
        self.Camera_label.setText("未开始")
        self.wait_label.setText("等待中")
        self.start_btn.clicked.connect(self.start_workers)
        self.stop_btn.clicked.connect(self.abort_workers)

        grid = QGridLayout()
        grid.setSpacing(10)
        grid.addWidget(self.start_btn,1,0)
        grid.addWidget(self.stop_btn,2,0)
        grid.addWidget(self.txt_print,4,0)
        grid.addWidget(self.wait_label,3,0)
        grid.addWidget(self.Camera_label,1,1,4,4)
        self.setLayout(grid)

        QThread.currentThread().setObjectName('main')
        self.__workers_done = None
        self.__threads = None
 def __init__(self, main_window):
     super().__init__()
     QThread.currentThread().setObjectName('tab_downloader')
     loadUi(resource_path('qt_assets/tabs/tab_download.ui'), self)
     self.main_window = main_window
     self.init_ui()
     self.show()
示例#6
0
    def __init__(self):
        super(MainWindow, self).__init__()
        uic.loadUi(qtCreatorFile, self)
        self.threads = []
        mainThreadID = int(QThread.currentThread().currentThreadId())
        print("MainThread ID: {}".format(mainThreadID))
        QThread.currentThread().setObjectName("Thread_Main")
        print("MainThread name is: {}".format(
            QThread.currentThread().objectName()))

        self.pb1.clicked.connect(self.pb1Action)
        self.pb1Object = UpdateLogger(2)
        self.pb1Thread = QThread()
        self.pb1Thread.setObjectName("Thread_pb1")
        self.threads.append(self.pb1Thread)
        self.pb1Object.moveToThread(self.pb1Thread)
        self.pb1Object.finished.connect(self.updateLogger)
        self.pb1Object.update.connect(self.updateLogger)
        self.pb1Thread.started.connect(self.pb1Object.running)

        self.pb2.clicked.connect(self.pb2Action)
        self.pb2Object = UpdateLogger(3)
        self.pb2Thread = QThread()
        self.pb2Thread.setObjectName("Thread_pb2")
        self.threads.append(self.pb2Thread)
        self.pb2Object.moveToThread(self.pb2Thread)
        print(self.pb2Object.threadName)
        self.pb2Object.finished.connect(self.updateLogger)
        self.pb2Object.update.connect(self.updateLogger)
        self.pb2Thread.started.connect(self.pb2Object.running)

        for t in self.threads:
            print(t.objectName())

        self.pb3.clicked.connect(self.pb3Action)
示例#7
0
    def __init__(self):

        super().__init__()
        self.setWindowTitle("Thread Example")
        form_layout = QVBoxLayout()
        self.setLayout(form_layout)
        self.resize(400, 800)

        self.btn_start = QPushButton()
        self.btn_start.clicked.connect(self.start_workers)
        self.btn_start.setText("Start {} threads".format(self.NUM_THREADS))
        form_layout.addWidget(self.btn_start)
        self.btn_stop = QPushButton()
        self.btn_stop.clicked.connect(self.abort_workers)
        self.btn_stop.setText("Stop threads")
        self.btn_stop.setDisabled(True)
        form_layout.addWidget(self.btn_stop)
        self.txt_log = QTextEdit()
        form_layout.addWidget(self.txt_log)
        self.txt_prg = QTextEdit()
        form_layout.addWidget(self.txt_prg)
        # 主线程名
        QThread.currentThread().setObjectName('main')
        self.__workers_done = None
        self.__threads = None
示例#8
0
    def __init__(self):
        super().__init__()

        self.setWindowTitle("Thread Example")
        form_layout = QVBoxLayout()
        self.setLayout(form_layout)
        self.resize(400, 800)

        self.button_start_threads = QPushButton()
        self.button_start_threads.clicked.connect(self.start_threads)
        self.button_start_threads.setText("Start {} threads".format(self.NUM_THREADS))
        form_layout.addWidget(self.button_start_threads)

        self.button_stop_threads = QPushButton()
        self.button_stop_threads.clicked.connect(self.abort_workers)
        self.button_stop_threads.setText("Stop threads")
        self.button_stop_threads.setDisabled(True)
        form_layout.addWidget(self.button_stop_threads)

        self.log = QTextEdit()
        form_layout.addWidget(self.log)

        self.progress = QTextEdit()
        form_layout.addWidget(self.progress)

        QThread.currentThread().setObjectName('main')  # threads can be named, useful for log output
        self.__workers_done = None
        self.__threads = None
示例#9
0
 def __init__(self):
     super().__init__()
     self.setWindowTitle("Dummy Files Creator")
     self.setWindowIcon(QtGui.QIcon(':/icon.png'))
     QThread.currentThread().setObjectName('main')
     self.__threads = []
     self._files_created = []
     self._create_ui()
示例#10
0
 def __init__(self):
     super().__init__()
     self.keyboard()
     QThread.currentThread().setObjectName('main')
     self.__work_done=None
     self.__threads=None
     self.animation=None
     self.animation = None
    def update_prices(self):
        if self.stop_exec:
            self.timer.stop()
            QThread.currentThread().quit()
            return

        for item in self.lookup_list:
            insn, rn, azn = item.split(':')
            try:
                s = boto3.Session(profile_name=self.profile, region_name=rn)
                ec2 = s.client('ec2')
                response = ec2.describe_spot_price_history(
                    AvailabilityZone=azn,
                    InstanceTypes=[insn],
                    ProductDescriptions=["Linux/UNIX"],
                    StartTime=datetime.datetime.utcnow() -
                    datetime.timedelta(seconds=5),
                    EndTime=datetime.datetime.utcnow())

                if response and 'SpotPriceHistory' in response:
                    if len(response['SpotPriceHistory']) >= 1:
                        if 'SpotPrice' in response['SpotPriceHistory'][0]:
                            self.prices[item] = float(
                                response['SpotPriceHistory'][0]['SpotPrice'])
                            self.lookup_list.remove(item)
                            self.sig_update_price.emit(item, self.prices[item])
                        else:
                            print("Price request response invalid for {} nop".
                                  format(item))
                            self.sig_update_price.emit(item, 0.00)
                            self.lookup_list.remove(item)
                    else:
                        print("Price request response invalid for {} (len)".
                              format(item))
                        self.sig_update_price.emit(item, 0.00)
                        self.lookup_list.remove(item)
                else:
                    print("Price request response invalid for {}".format(item))
                    self.sig_update_price.emit(item, 0.00)
                    self.lookup_list.remove(item)
            except ClientError as e:
                print(e)
                self.sig_error.emit(str(e))
                pass
            except gaierror as e:
                print(e)
                self.sig_error.emit(str(e))
                pass
            except NewConnectionError as e:
                print(e)
                self.sig_error.emit(str(e))
                pass
            except EndpointConnectionError as e:
                print(e)
                self.sig_error.emit(str(e))
                pass
示例#12
0
    def __init__(self, parent=None):

        super(MainGui, self).__init__(parent)
        self.setupUi(self)
        self.initial_ui()

        # Make any cross object connections.
        self._connectSignals()
        QThread.currentThread().setObjectName(
            'main')  # threads can be named, useful for log output
        self.__threads = None
示例#13
0
文件: runner.py 项目: jni/cecog
    def _load_data(self, mappings, channel):
        dtable = HmmDataTable()

        # XXX read region names from hdf not from settings
        chreg = "%s__%s" %(channel, self.ecopts.regionnames[channel])

        progress = ProgressMsg(max=len(self.files))

        for file_ in self.files:
            position = splitext(basename(file_))[0]
            progress.meta = meta=("loading plate: %s, file: %s"
                                  %(self.plate, file_))
            progress.increment_progress()


            QThread.currentThread().interruption_point()
            self.parent().progressUpdate.emit(progress)
            QtCore.QCoreApplication.processEvents()

            try:
                ch5 = cellh5.CH5File(file_, "r", cached=True)
                for pos in ch5.iter_positions():
                    # only segmentation
                    if not pos.has_classification(chreg):
                        continue

                    # make dtable aware of all positions, sometime they contain
                    # no tracks and I don't want to ignore them
                    dtable.add_position(position, mappings[position])
                    if not pos.has_events():
                        continue

                    objidx = np.array( \
                        pos.get_events(not self.ecopts.ignore_tracking_branches),
                        dtype=int)
                    tracks = pos.get_class_label(objidx, chreg)
                    try:
                        probs = pos.get_prediction_probabilities(objidx, chreg)
                    except KeyError as e:
                        probs = None

                    grp_coord = cellh5.CH5GroupCoordinate( \
                        chreg, pos.pos, pos.well, pos.plate)
                    dtable.add_tracks(tracks, position, mappings[position],
                                      objidx, grp_coord, probs)
            finally:
                ch5.close()

        if dtable.is_empty():
            raise RuntimeError(
                "No data found for plate '%s' and channel '%s' "
                %(self.plate, channel))
        return dtable, self._load_classdef(chreg)
示例#14
0
    def _load_data(self, mappings, channel):
        dtable = HmmDataTable()

        # XXX read region names from hdf not from settings
        chreg = "%s__%s" % (channel, self.ecopts.regionnames[channel])

        progress = ProgressMsg(max=len(self.files))

        for file_ in self.files:
            position = splitext(basename(file_))[0]
            progress.meta = meta = ("loading plate: %s, file: %s" %
                                    (self.plate, file_))
            progress.increment_progress()

            QThread.currentThread().interruption_point()
            self.parent().progressUpdate.emit(progress)
            QtCore.QCoreApplication.processEvents()

            try:
                ch5 = cellh5.CH5File(file_, "r", cached=True)
                for pos in ch5.iter_positions():
                    # only segmentation
                    if not pos.has_classification(chreg):
                        continue

                    # make dtable aware of all positions, sometime they contain
                    # no tracks and I don't want to ignore them
                    dtable.add_position(position, mappings[position])
                    if not pos.has_events():
                        continue

                    objidx = np.array( \
                        pos.get_events(not self.ecopts.ignore_tracking_branches),
                        dtype=int)
                    tracks = pos.get_class_label(objidx, chreg)
                    try:
                        probs = pos.get_prediction_probabilities(objidx, chreg)
                    except KeyError as e:
                        probs = None

                    grp_coord = cellh5.CH5GroupCoordinate( \
                        chreg, pos.pos, pos.well, pos.plate)
                    dtable.add_tracks(tracks, position, mappings[position],
                                      objidx, grp_coord, probs)
            finally:
                ch5.close()

        if dtable.is_empty():
            raise RuntimeError(
                "No data found for plate '%s' and channel '%s' " %
                (self.plate, channel))
        return dtable, self._load_classdef(chreg)
示例#15
0
 def get_hoster_links(self) -> None:
     try:
         req = self.scraper.get(self.link_url)
         bs = BeautifulSoup(req.text, 'lxml')
         links = bs.select('div.post h2[style="text-align: center;"]')
         self.setHosters.emit(links)
     except HTTPError:
         print(sys.exc_info()[0])
         # noinspection PyTypeChecker
         QMessageBox.critical(None, 'ERROR NOTIFICATION', sys.exc_info()[0])
         QThread.currentThread().quit()
     except IndexError:
         self.noLinks.emit()
         QThread.currentThread().quit()
def detect_video(widget=None, with_tracking=None):
    if not widget:
        args = arg_parse()
    else:
        args = widget.args
    # Check files
    if args.video != 0:
        if not os.path.exists(args.video):
            print_info(widget, True, "error",
                       "No file with the name {}".format(args.video))
        mimetypes.init()
        mime_start = mimetypes.guess_type(args.video)[0]
        if mime_start:
            mime_start = mime_start.split('/')[0]
            if mime_start != 'video':
                print_info(widget, True, "error",
                           "No video file with the name {}".format(args.video))

    # Set up the neural network
    # Detection phase
    video_file = args.video  # or path to the video file.
    if type(video_file) == int:
        # for webcam
        reading_thread = ReadFramesThread(0, args, with_tracking,
                                          widget).start()
    else:
        reading_thread = ReadFramesThread(video_file, args, with_tracking,
                                          widget).start()

    while reading_thread.has_images() or (not reading_thread.stopped):
        if widget.obj.cancel:
            reading_thread.cancel()
            widget.obj.cancel = False
            QThread.currentThread().quit()
            return

        if widget.obj.pause:
            reading_thread.pause()
            widget.obj.pauseMutex.lock()
            widget.obj.pauseCond.wait(widget.obj.pauseMutex)
            widget.obj.pauseMutex.unlock()

        image_handler = reading_thread.get_image()
        last_contour = image_handler.get_last_contour()
        if last_contour:
            print_info(widget, False, "contour_ready", last_contour)
        print_info(widget, False, "image_ready", image_handler)
        key = cv2.waitKey(1)
        if key & 0xFF == ord('q'):
            break
示例#17
0
    def on_timeout(self):
        if self.stop_exec:
            self.timer.stop()
            QThread.currentThread().quit()

        if self.do_update:
            self.do_update = False
            self.items.clear()
            try:
                s = boto3.Session(profile_name=self.profile,
                                  region_name=self.region)
                s3 = s.client('s3')
                response = s3.list_objects(Bucket='cloudian-qtspots',
                                           Prefix=self.prefix)
                if 'Contents' in response:
                    for o in response['Contents']:
                        if self.rfilter != '':
                            if pathlib.PurePosixPath(o['Key']).name.endswith(
                                    self.rfilter):
                                self.items.append(o['Key'].replace(
                                    self.prefix, ''))
                                self.sig_progress.emit("Loaded {}".format(
                                    pathlib.PurePosixPath(o['Key']).name))
                        else:
                            self.items.append(o['Key'].replace(
                                self.prefix, ''))
                            self.sig_progress.emit("Loaded {}".format(
                                pathlib.PurePosixPath(o['Key']).name))
                self.sig_update_finished.emit(self.items)
                if len(self.items) == 0:
                    self.sig_update_error.emit(
                        "Loader returned an empty result.")

            except ClientError as e:
                print(e)
                self.sig_update_error.emit(str(e))
                pass
            except gaierror as e:
                print(e)
                self.sig_update_error.emit(str(e))
                pass
            except NewConnectionError as e:
                print(e)
                self.sig_update_error.emit(str(e))
                pass
            except EndpointConnectionError as e:
                print(e)
                self.sig_update_error.emit(str(e))
                pass
示例#18
0
    def _run_blocking_event_loop(self, timeout: float = None) -> None:
        """Start the main event loop for this :py:class:`ImageDisplay`.
        """
        LOG.info("Running Qt Main Event Loop.")
        # Run the Qt main event loop to update the display and
        # process timeout and/or key events.
        if self.event_loop_is_running():
            raise RuntimeError("Only one background thread is allowed.")

        self._event_loop = QThread.currentThread()
        if timeout is not None:
            milliseconds = int(timeout * 1000)
            timer = QTimer()
            timer.setInterval(milliseconds)
            timer.setSingleShot(True)
            timer.timeout.connect(self._view.onTimer)
            timer.start()
        LOG.debug("Starting Qt Main Event Loop (exec_)")
        self._application.exec_()
        LOG.debug("Qt Main Event Loop (exec_) has ended.")
        if timeout is not None:
            timer.stop()
            timer.timeout.disconnect(self._view.onTimer)
        self._event_loop = None

        LOG.info("Qt Main Event Loop finished (event loop=%s, closed=%s).",
                 self.event_loop_is_running(), self.closed)
示例#19
0
    def work(self):
        """
        Pretend this worker method does work that takes a long time. During this time, the thread's
        event loop is blocked, except if the application's processEvents() is called: this gives every
        thread (incl. main) a chance to process events, which in this sample means processing signals
        received from GUI (such as abort).
        """
        thread_name = QThread.currentThread().objectName()
        thread_id = int(
            QThread.currentThreadId())  # cast to int() is necessary
        self.sig_msg.emit('Running worker #{} from thread "{}" (#{})'.format(
            self.__id, thread_name, thread_id))

        for step in range(100):
            time.sleep(0.1)
            self.sig_step.emit(self.__id, 'step ' + str(step))

            # check if we need to abort the loop; need to process events to receive signals;
            # app.processEvents()  # this could cause change to self.__abort
            if self.__abort:
                # note that "step" value will not necessarily be same for every thread
                self.sig_msg.emit('Worker #{} aborting work at step {}'.format(
                    self.__id, step))
                break

        self.sig_done.emit(self.__id)
示例#20
0
 def echo(self, message):
     """Cheap debug tool
     """
     now = Datetime.utcnow()
     messageBar = self.iface.messageBar()
     threadName = QThread.currentThread().objectName()
     messageBar.pushMessage(threadName, "[%s] %s" % (now, message))
示例#21
0
    def _task_finished(self, f):
        """
        Parameters
        ----------
        f : Future
            The future instance holding the result of learner evaluation.
        """
        assert self.thread() is QThread.currentThread()
        assert self._task is not None
        assert self._task.future is f
        assert f.done()

        self._task = None
        self.progressBarFinished()

        try:
            results = f.result()  # type: dict

            self.on_finish(results)

        except Exception as ex:
            # Log the exception with a traceback
            log = logging.getLogger()
            log.exception(__name__, exc_info=True)
            self.error("Exception occurred during evaluation: {!r}".format(ex))
示例#22
0
文件: test_future.py 项目: gpa14/enki
 def f2():
     future = ac.start(em2.g, lambda x: x, QThread.currentThread())
     # The doneSignal won't be processed without an event loop. A
     # thread pool doesn't create one, so make our own to run ``g``.
     qe = QEventLoop()
     future._signalInvoker.doneSignal.connect(qe.exit)
     qe.exec_()
示例#23
0
 def f2():
     future = ac.start(em2.g, lambda x: x, QThread.currentThread())
     # The doneSignal won't be processed without an event loop. A
     # thread pool doesn't create one, so make our own to run ``g``.
     qe = QEventLoop()
     future._signalInvoker.doneSignal.connect(qe.exit)
     qe.exec_()
示例#24
0
 def begin(self):
     for page in range(self.maxpages):
         if QThread.currentThread().isInterruptionRequested():
             return
         self.scrape(page)
     self.complete = True
     self.workFinished.emit()
示例#25
0
 def helperForObservable(self,
                         observable: Observable,
                         interests=None,
                         notify: Callable = None,
                         create: bool = False,
                         remove: bool = False) -> Observable.Observer:
     if self._qObserverHelpers is None:
         raise RuntimeError("It seems QObserver's constructor was not "
                            "called (QObserverHelpers is not set)")
     key = type(observable).Change
     if key not in self._qObserverHelpers:
         if not create:
             raise RuntimeError("No QObserverHelper for observing "
                                f"{type(observable)} in {self}")
         helper = QObserver.QObserverHelper(self, observable, interests,
                                            notify)
         # make sure that event processing for the helper object
         # is done in th main thread:
         mainThread = QApplication.instance().thread()
         if mainThread != QThread.currentThread():
             LOG.warning("Moving observer helper for %s to main Thread",
                         observable)
             helper.moveToThread(mainThread)
         self._qObserverHelpers[key] = helper
     elif remove:
         return self._qObserverHelpers.pop(key)
     return self._qObserverHelpers[key]
示例#26
0
    def observe(self,
                observable: Observable,
                interests: Observable.Change = None,
                notify: Callable = None) -> None:
        """Observe an :py:class:`Observable`.

        Note: The type of the observable (currently) has to be
        suitable for this class, i.e. it is not necessary to declare
        it with `qobservables` arguments at class definition, but
        that may change in future.

        Arguments
        ---------
        observable: Observable
            The object to observer.
        interests:
            Notification we are interested in.
        notify: Callable
            The method to invoke on notification. If none is provided,
            the default notifiaction method of the observable is used.

        Raises
        ------
        TypeError:
            The observable is of inapropriate type.
        """
        if not isinstance(observable, Observable):
            raise TypeError(f"{type(self).__name__} is trying to observe "
                            f"a non-observable ({type(observable)})")
        mainThread = QApplication.instance().thread()
        currentThread = QThread.currentThread()
        qObserverHelper = \
            self.helperForObservable(observable, create=True,
                                     interests=interests, notify=notify)
        qObserverHelper.startObservation(interests=interests, notify=notify)
示例#27
0
    def _analyze(self, cellanalyzer):

        thread = QThread.currentThread()
        imax = sum([len(n) for n in self.sample_positions.values()])
        thread.statusUpdate(min=0, max=imax)

        stopwatch = StopWatch(start=True)
        crd = Coordinate(self.plate_id, self.position,
                         self._frames, list(set(self.ch_mapping.values())))

        for frame, channels in self._imagecontainer( \
            crd, interrupt_channel=True, interrupt_zslice=True):

            thread.interruption_point()
            txt = '%s, %s, T %d, (%d/%d)' \
                  %(self.plate_id, self.position,
                    frame, self._frames.index(frame)+1, len(self._frames))

            thread.statusUpdate(meta="Classifier training: ",
                                text=txt, interval=stopwatch.interim(), increment=True)

            stopwatch.reset(start=True)
            # initTimepoint clears channel_registry
            cellanalyzer.initTimepoint(frame)
            self.register_channels(cellanalyzer, channels)

            cellanalyzer.collectObjects(self.plate_id, self.position, self.sample_readers,
                                        self.learner)
示例#28
0
    def panel(self, panel_id: str,
              create: bool = False, show: bool = False) -> Panel:
        """Get the panel for a given panel identifier. Optionally
        create that panel if it does not yet exist.

        Arguments
        ---------
        panel_id:
            The panel identifier. This must be one of the identifiers
            from the _panelMetas list.
        create:
            A flag indicating if the panel should be created in case
            it does not exist yet.
        show:
            A flag indicatin if the panel should be shown, i.e., made
            the current panel.

        Raises
        ------
        KeyError:
            The given panel identifier is not known.
        ValueError:
            The panel requested has not yet been created and no creation
            was requested.
        """
        if not any(m.id == panel_id for m in self._panelMetas):
            raise KeyError(f"There is no panel with id '{panel_id}' "
                           "in DeepVisMainWindow.")

        if QThread.currentThread() != self.thread():
            # method was called from different thread
            # emit signal to run in main thread
            self.panel_signal.emit(panel_id, create, show)
            return

        meta = self._panelMeta(panel_id)
        panel = None
        if create:
            index = 0
            label = self._tabs.tabText(index)
            for m in self._panelMetas:
                if label == meta.label:
                    panel = self._tabs.widget(index)
                    break
                if m.id == meta.id:
                    self._newPanel(meta, index, m.label, show)
                    # FIXME[hack]: panel creation is asynchronous and
                    # hence does not really fit in this synchronous
                    # function! API should be changed accordingly!
                    panel = None
                    break
                if label == m.label:
                    index += 1
                    label = self._tabs.tabText(index)
        else:
            index = self._panelTabIndex(panel_id)
            panel = self._tabs.widget(index)
        if show and panel is not None:
            self._tabs.setCurrentIndex(index)
        return panel
示例#29
0
def call_in_gui_thread(function, *args, **kw):
    application = Application.instance
    if QThread.currentThread() is Application.gui_thread:
        return function(*args, **kw)
    else:
        application.postEvent(application,
                              CallFunctionEvent(function, args, kw))
示例#30
0
 def progress_check(self, stream = None, chunk = None, bytes_remaining = None):
     # Gets the percentage of the file that has been downloaded.
     # print(stream, file_size)
     file_size = stream.filesize
     percent = (100*(file_size-bytes_remaining))/file_size
     now_thread = QThread.currentThread()
     now_thread.set_value.emit(percent)
示例#31
0
    def direct(self, flows):
        flownum = 0
        child_types = []
        for flownum, flow in enumerate(flows, start=1):
            self.raw_line.emit("Flow {0}: {1} -> {2}".format(
                flownum, flow.source, flow.target))
            for rule in sorted(flow.rules):
                self.raw_line.emit("    {0}".format(rule))

            self.raw_line.emit("")

            # Generate results for flow browser
            if self.out:
                child_types.append(
                    (flow.target, sorted(str(r) for r in flow.rules)))
            else:
                child_types.append(
                    (flow.source, sorted(str(r) for r in flow.rules)))

            if QThread.currentThread().isInterruptionRequested():
                break
            else:
                QThread.yieldCurrentThread()

        self.raw_line.emit("{0} information flow(s) found.\n".format(flownum))
        self.log.info("{0} information flow(s) found.".format(flownum))

        # Update browser:
        root_type = self.query.source if self.out else self.query.target
        self.flows.emit(str(root_type), self.out, sorted(child_types))
示例#32
0
文件: dta.py 项目: jakev/setools
    def direct(self, transitions):
        i = 0
        child_types = []
        for i, step in enumerate(transitions, start=1):
            self.raw_line.emit("Transition {0}: {1} -> {2}\n".format(i, step.source, step.target))
            sort_transition(step)
            print_transition(self.raw_line.emit, step)

            # Generate results for flow browser
            if self.out:
                child_types.append((step.target, step))
            else:
                child_types.append((step.source, step))

            if QThread.currentThread().isInterruptionRequested():
                break
            else:
                QThread.yieldCurrentThread()

        self.raw_line.emit("{0} domain transition(s) found.".format(i))
        self.log.info("{0} domain transition(s) found.".format(i))

        # Update browser:
        root_type = self.query.source if self.out else self.query.target
        self.trans.emit(str(root_type), self.out, sorted(child_types))
示例#33
0
    def run(self):
        print(QThread.currentThread(), ' is running ...')
        print(QDir.homePath(), QDir.currentPath())
        rootdir = QDir.homePath() + '/pics'
        list = os.listdir(rootdir)  #列出文件夹下所有的目录与文件
        for i in range(0, min(len(list), 200)):
            path = os.path.join(rootdir, list[i])
            types = ('.bmp', '.jpg', '.tif', '.png')
            if os.path.isfile(path) and path.endswith(types):
                # self.image_list[path] = QImage(path)
                self.image_list.append((path, QImage(path)))
        self.image_list.sort()
        sorted(self.image_list, key=operator.itemgetter(0))

        if len(self.image_list) == 0:
            return
        self.bStop = False
        while self.isRunning():
            # break
            # for (k,v) in self.image_list.items():  # 字典类型遍历  随机访问 会乱序
            for k, v in enumerate(self.image_list):
                # print(k,v)
                # print(type(k),type(v))
                # self.evt_showImg.emit(k,v)
                self.evt_showImg.emit(v[0], v[1])  ## 发射自定义信号
                if (self.isInterruptionRequested()):
                    print("----> get isInterruptionRequested")
                    self.bStop = True
                    break
                QThread.msleep(25)
            if self.bStop:
                break
        print("----> thread quit here!!")
示例#34
0
    def direct(self, transitions):
        i = 0
        child_types = []
        for i, step in enumerate(transitions, start=1):
            self.raw_line.emit("Transition {0}: {1} -> {2}\n".format(
                i, step.source, step.target))
            sort_transition(step)
            print_transition(self.raw_line.emit, step)

            # Generate results for flow browser
            if self.out:
                child_types.append((step.target, step))
            else:
                child_types.append((step.source, step))

            if QThread.currentThread().isInterruptionRequested():
                break
            else:
                QThread.yieldCurrentThread()

        self.raw_line.emit("{0} domain transition(s) found.".format(i))
        self.log.info("{0} domain transition(s) found.".format(i))

        # Update browser:
        root_type = self.query.source if self.out else self.query.target
        self.trans.emit(str(root_type), self.out, sorted(child_types))
示例#35
0
    def direct(self, flows):
        flownum = 0
        child_types = []
        for flownum, flow in enumerate(flows, start=1):
            self.raw_line.emit("Flow {0}: {1} -> {2}".format(flownum, flow.source, flow.target))
            for rule in sorted(flow.rules):
                self.raw_line.emit("    {0}".format(rule))

            self.raw_line.emit("")

            # Generate results for flow browser
            if self.out:
                child_types.append((flow.target, sorted(str(r) for r in flow.rules)))
            else:
                child_types.append((flow.source, sorted(str(r) for r in flow.rules)))

            if QThread.currentThread().isInterruptionRequested():
                break
            else:
                QThread.yieldCurrentThread()

        self.raw_line.emit("{0} information flow(s) found.\n".format(flownum))
        self.log.info("{0} information flow(s) found.".format(flownum))

        # Update browser:
        root_type = self.query.source if self.out else self.query.target
        self.flows.emit(str(root_type), self.out, sorted(child_types))
示例#36
0
文件: future.py 项目: freason/enki
 def foo(a, b):
     print('Foo {} {} in thread {}'.format(a, b, QThread.currentThread()))
     if a == 3:
         # As a test, raise an exception. See if a useful traceback is
         # printed.
         asdf
     time.sleep(0.3)
     return a + 0.1
示例#37
0
    def init(self):
        print("Worker.init:", QThread.currentThread())
        # Delay creation so we are in the correct thread
        self.dbus_loop = DBusQtMainLoop(set_as_default=False)
        self.session_bus = dbus.SessionBus(mainloop=self.dbus_loop)
        self.dbus_thumbnailer = DBusThumbnailer(self.session_bus)

        self.sig_thing_requested.connect(self.on_thing_requested)
示例#38
0
文件: future.py 项目: gpa14/enki
 def foo(a, b):
     print(('Foo ' + str(a) + str(b) + ' in thread ' + str(QThread.currentThread())))
     if a == 3:
         # As a test, raise an exception. See if a useful traceback is
         # printed.
         asdf
     time.sleep(0.3)
     return a + 0.1
示例#39
0
 def test_5(self):
     for _ in self.poolAndThread:
         with AsyncController(_) as ac:
             def f(currentThread):
                 self.assertNotEqual(currentThread, QThread.currentThread())
             em = Emitter()
             with WaitForSignal(em.bing, 1000):
                 ac.start(em.g, f, QThread.currentThread())
示例#40
0
文件: runner.py 项目: jni/cecog
    def __call__(self):
        if self.params_ec.position_labels:
            self._check_mapping_files()

        progress = ProgressMsg(max=len(self.plates), meta="Error correction...")

        for i, plate in enumerate(self.plates):
            QThread.currentThread().interruption_point()
            progress.text = ("Plate: '%s' (%d / %d)"
                             %(plate, i+1, len(self.plates)))
            self.progressUpdate.emit(progress)

            ch5file = join(self._outdirs[plate], 'hdf5', "_all_positions.ch5")
            runner = PositionRunner(plate, self._outdirs[plate],
                                    self.params_ec, parent=self,
                                    ch5file=ch5file)
            runner()
            self.progressUpdate.emit(progress)
示例#41
0
def excepthook(exctype, excvalue, exctb):
    """Called when a Python exception goes unhandled."""
    from traceback import format_exception
    sys.stderr.write(''.join(format_exception(exctype, excvalue, exctb)))
    if exctype != KeyboardInterrupt:
        # show dialog, but not when in non-GUI thread
        if QThread.currentThread() == qApp.thread():
            import exception
            exception.ExceptionDialog(exctype, excvalue, exctb)
示例#42
0
文件: future.py 项目: gpa14/enki
    def _invoke(self):
        if self._requestCancel:
            # Skip canceled callables.
            self._state = self.STATE_CANCELED
        else:
            # Run the function, catching any exceptions.
            self._state = self.STATE_RUNNING
            QThread.currentThread().setPriority(self._futurePriority)
            try:
                self._result = self._f(*self._args, **self._kwargs)
            except:
                # Save not just the exception, but also the traceback to provide
                # better debugging info when this is re-raised in the calling
                # thread.
                self._exc_info = sys.exc_info()

            # Report the results.
            self._state = self.STATE_FINISHED
            self._signalInvoker.doneSignal.emit(self)
示例#43
0
 def function_wrapper(*args, **kw):
     application = Application.instance
     if QThread.currentThread() is Application.gui_thread:
         return function(*args, **kw)
     else:
         if wait:
             executor = FunctionExecutor(function)
             application.postEvent(application, CallFunctionEvent(executor, args, kw))
             return executor.wait()
         else:
             application.postEvent(application, CallFunctionEvent(function, args, kw))
示例#44
0
    def _load_data(self, channel):

        dtable = HmmDataTable()

        # XXX read region names from hdf not from settings
        mask = "%s__%s" %(channel, self.ecopts.regionnames[channel])

        c = 2
        if self.ecopts.write_gallery:
            c += 1

        thread = QThread.currentThread()

        with Ch5File(self.ch5file, mode="r") as ch5:
            layout = ch5.layout(self.plate)
            mappings = PlateMapping(layout)
            thread.statusUpdate(min=0, max=ch5.numberSites(self.plate) + c)

            for site in ch5.iterSites():

                ws = "%s_%02d" %(site.well, int(site.site))
                thread.statusUpdate(
                    text="loading plate: %s, file: %s" %(site.plate, ws))
                thread.increment.emit()
                thread.interruption_point()
                QtCore.QCoreApplication.processEvents()

                if not ch5.hasClassifier(mask):
                    continue

                # make dtable aware of all positions, sometime they contain
                # no tracks and I don't want to ignore them
                dtable.add_position(ws, mappings[ws])
                if not ch5.hasEvents(site):
                    continue

                objidx = ch5.events(site, self.ecopts.ignore_tracking_branches)
                tracks = np.asarray(ch5.predictions(site, mask))[objidx]

                try:
                    probs = ch5.probabilities(site, mask)[objidx, :]
                except KeyError as e:
                    probs = None

                site.mask = mask
                dtable.add_tracks(tracks, ws, mappings[ws],
                                  objidx, site, probs)

        if dtable.is_empty():
            raise RuntimeError(
                "No data found for plate '%s' and channel '%s' "
                %(self.plate, channel))
        return dtable, self._load_classdef(mask)
示例#45
0
    def direct(self, transitions):
        i = 0
        for i, step in enumerate(transitions, start=1):
            self.raw_line.emit("Transition {0}: {1} -> {2}\n".format(i, step.source, step.target))
            self.print_transition(step)

            if QThread.currentThread().isInterruptionRequested() or (i >= self.query.limit):
                break
            else:
                QThread.yieldCurrentThread()

        self.raw_line.emit("{0} domain transition(s) found.".format(i))
示例#46
0
 def g(self, future):
     self.thread = QThread.currentThread()
     # Always bing, even if there's an exception.
     try:
         # Retrieve the result, even if it won't be checked, to make sure
         # that no exceptions were raised.
         self.result = future.result
         if self.expected:
             self.assertEqual(self.expected, self.result)
     except:
         raise
     finally:
         self.bing.emit()
示例#47
0
文件: ui.py 项目: GdZ/FeelUOwn
 def show_message(self, text, error=False):
     if self.isVisible():
         self.queue.append({'error': error, 'message': text})
         self._interval = 1.5
         return
     if error:
         self._set_error_style()
     else:
         self._set_normal_style()
     self.setText(str(len(self.queue)) + ': ' + text)
     self.show()
     self.timer.moveToThread(QThread.currentThread())
     self.timer.start(self._interval * 1000)
示例#48
0
def main(argv):
    signal.signal(signal.SIGINT, signal.SIG_DFL)

    app = QCoreApplication(argv)

    print("Starting:", QThread.currentThread())

    fac1 = WorkerFacade("1")
    fac2 = WorkerFacade("2")

    for i in range(10):
        print("Requesting", i)
        fac1.request_thing("Foo" + str(i), lambda x: print("Got:", x))
        fac2.request_thing("Foo" + str(i), lambda x: print("Got:", x))

    def quits():
        print("calling quits")
        fac1.on_quit()
        fac2.on_quit()

    def app_quit():
        print("App quit")
        quits()
        app.quit()

    # Calling QThread.quit() will not terminate the thread until all
    # signals have been processed
    #
    # Or not, calling quits early will cause a segfault when dbus is
    # involved. The requested quit signal isn't getting processed
    QTimer.singleShot(2000, quits)

    # QThread must be all destroyed before the application is
    # quitting, else ugly "Aborted (core dumped)" will result
    QTimer.singleShot(1500, app_quit)

    print("Entering event loop:", QThread.currentThread())
    app.exec()
    print("Cleanly exited")
示例#49
0
    def direct(self, flows):
        flownum = 0
        for flownum, flow in enumerate(flows, start=1):
            self.raw_line.emit("Flow {0}: {1} -> {2}".format(flownum, flow.source, flow.target))
            for rule in sorted(flow.rules):
                self.raw_line.emit("    {0}".format(rule))

            self.raw_line.emit("")

            if QThread.currentThread().isInterruptionRequested() or (flownum >= self.query.limit):
                break
            else:
                QThread.yieldCurrentThread()

        self.raw_line.emit("{0} information flow(s) found.\n".format(flownum))
示例#50
0
    def __call__(self):

        thread = QThread.currentThread()

        for i, plate in enumerate(self.plates):
            thread.interruption_point()
            ch5file = join(self._outdirs[plate], "%s.ch5" %plate)

            runner = PositionRunner(plate, self._outdirs[plate],
                                    self.params_ec, parent=self,
                                    ch5file=ch5file)
            runner()

            txt = ("Plate: '%s' (%d / %d)" %(plate, i+1, len(self.plates)))
            thread.statusUpdate(text=txt)
示例#51
0
    def transitive(self, paths):
        i = 0
        for i, path in enumerate(paths, start=1):
            self.raw_line.emit("Domain transition path {0}:".format(i))

            for stepnum, step in enumerate(path, start=1):

                self.raw_line.emit("Step {0}: {1} -> {2}\n".format(stepnum, step.source,
                                                                   step.target))
                self.print_transition(step)

            if QThread.currentThread().isInterruptionRequested() or (i >= self.query.limit):
                break
            else:
                QThread.yieldCurrentThread()

        self.raw_line.emit("{0} domain transition path(s) found.".format(i))
示例#52
0
    def test_6(self):
        # Don't test with one pooled thread -- this test expects at least two
        # threads.
        with AsyncController(2) as ac:
            q = Queue()

            def f():
                q.get()
                return QThread.currentThread()
            em1 = Emitter()
            em2 = Emitter()
            ac.start(em1.g, f)
            ac.start(em2.g, f)
            with WaitForSignal(em1.bing, 1000), WaitForSignal(em2.bing, 1000):
                q.put(None)
                q.put(None)
            s = set([em1.result, em2.result, QThread.currentThread()])
            self.assertEqual(len(s), 3)
示例#53
0
 def read(self):
     """Blocking read loop which emits got_line when a new line arrived."""
     # We open as R/W so we never get EOF and have to reopen the pipe.
     # See http://www.outflux.net/blog/archives/2008/03/09/using-select-on-a-fifo/
     # We also use os.open and os.fdopen rather than built-in open so we can
     # add O_NONBLOCK.
     fd = os.open(self._filepath, os.O_RDWR |
                  os.O_NONBLOCK)  # pylint: disable=no-member
     self.fifo = os.fdopen(fd, 'r')
     while True:
         log.procs.debug("thread loop")
         ready_r, _ready_w, _ready_e = select.select([self.fifo], [], [], 1)
         if ready_r:
             log.procs.debug("reading data")
             for line in self.fifo:
                 self.got_line.emit(line.rstrip())
         if QThread.currentThread().isInterruptionRequested():
             self.finished.emit()
             return
示例#54
0
    def run(self):
        flownum = 0
        child_types = []
        for flownum, flow in enumerate(self.query.infoflows(self.type_, out=self.out), start=1):
            # Generate results for flow browser
            if self.out:
                child_types.append((flow.target, sorted(str(r) for r in flow.rules)))
            else:
                child_types.append((flow.source, sorted(str(r) for r in flow.rules)))

            if QThread.currentThread().isInterruptionRequested():
                break
            else:
                QThread.yieldCurrentThread()

        self.log.debug("{0} additional information flow(s) found.".format(flownum))

        # Update browser:
        self.flows.emit(sorted(child_types))
示例#55
0
文件: dta.py 项目: jakev/setools
    def run(self):
        transnum = 0
        child_types = []
        for transnum, trans in enumerate(self.query.transitions(self.type_), start=1):
            # Generate results for browser
            sort_transition(trans)

            if self.out:
                child_types.append((trans.target, trans))
            else:
                child_types.append((trans.source, trans))

            if QThread.currentThread().isInterruptionRequested():
                break
            else:
                QThread.yieldCurrentThread()

        self.log.debug("{0} additional domain transition(s) found.".format(transnum))

        # Update browser:
        self.trans.emit(sorted(child_types))
示例#56
0
    def transitive(self, paths):
        pathnum = 0
        for pathnum, path in enumerate(paths, start=1):
            self.raw_line.emit("Flow {0}:".format(pathnum))
            for stepnum, step in enumerate(path, start=1):
                self.raw_line.emit("  Step {0}: {1} -> {2}".format(stepnum,
                                                                   step.source,
                                                                   step.target))

                for rule in sorted(step.rules):
                    self.raw_line.emit("    {0}".format(rule))

                self.raw_line.emit("")

            if QThread.currentThread().isInterruptionRequested() or (pathnum >= self.query.limit):
                break
            else:
                QThread.yieldCurrentThread()

            self.raw_line.emit("")

        self.raw_line.emit("{0} information flow path(s) found.\n".format(pathnum))
示例#57
0
    def update(self):
        """Run the query and update results."""
        self.model.beginResetModel()

        results = []
        counter = 0

        for counter, item in enumerate(self.query.results(), start=1):
            results.append(item)

            self.raw_line.emit(str(item))

            if QThread.currentThread().isInterruptionRequested():
                break
            elif not counter % 10:
                # yield execution every 10 rules
                QThread.yieldCurrentThread()

        self.model.resultlist = results
        self.model.endResetModel()

        self.finished.emit(counter)
示例#58
0
 def f(assertEqual, priority):
     assertEqual(QThread.currentThread().priority(), priority)
示例#59
0
 def f1():
     em2 = Emitter()
     with WaitForSignal(em2.bing, 1000):
         ac.start(em2.g, lambda x: x, QThread.currentThread())
     self.assertEqual(em2.thread, em2.result)
示例#60
0
def messageHandler(msgType, *args):
    """
    Module function handling messages.
    
    @param msgType type of the message (integer, QtMsgType)
    @param args message handler arguments, for PyQt4 message to be shown
        (bytes), for PyQt5 context information (QMessageLogContext) and
        message to be shown (bytes)
    """
    if len(args) == 2:
        context = args[0]
        message = args[1]
    else:
        message = args[0]
    if __msgHandlerDialog:
        try:
            if msgType == QtDebugMsg:
                messageType = QCoreApplication.translate(
                    "E5ErrorMessage", "Debug Message:")
            elif msgType == QtWarningMsg:
                messageType = QCoreApplication.translate(
                    "E5ErrorMessage", "Warning:")
            elif msgType == QtCriticalMsg:
                messageType = QCoreApplication.translate(
                    "E5ErrorMessage", "Critical:")
            elif msgType == QtFatalMsg:
                messageType = QCoreApplication.translate(
                    "E5ErrorMessage", "Fatal Error:")
            if isinstance(message, bytes):
                message = Utilities.decodeBytes(message)
            message = message.replace("\r\n", "<br/>")\
                             .replace("\n", "<br/>")\
                             .replace("\r", "<br/>")
            if len(args) == 2:
                msg = "<p><b>{0}</b></p><p>{1}</p><p>File: {2}</p>" \
                    "<p>Line: {3}</p><p>Function: {4}</p>".format(
                        messageType, Utilities.html_uencode(message),
                        context.file, context.line, context.function)
            else:
                msg = "<p><b>{0}</b></p><p>{1}</p>".format(
                    messageType, Utilities.html_uencode(message))
            if QThread.currentThread() == qApp.thread():
                __msgHandlerDialog.showMessage(msg)
            else:
                QMetaObject.invokeMethod(
                    __msgHandlerDialog,
                    "showMessage",
                    Qt.QueuedConnection,
                    Q_ARG(str, msg))
            return
        except RuntimeError:
            pass
    elif __origMsgHandler:
        __origMsgHandler(msgType, message)
        return
    
    if msgType == QtDebugMsg:
        messageType = QCoreApplication.translate(
            "E5ErrorMessage", "Debug Message")
    elif msgType == QtWarningMsg:
        messageType = QCoreApplication.translate(
            "E5ErrorMessage", "Warning")
    elif msgType == QtCriticalMsg:
        messageType = QCoreApplication.translate(
            "E5ErrorMessage", "Critical")
    elif msgType == QtFatalMsg:
        messageType = QCoreApplication.translate(
            "E5ErrorMessage", "Fatal Error")
    if isinstance(message, bytes):
        message = message.decode()
    if len(args) == 2:
        print("{0}: {1} in {2} at line {3} ({4})".format(
            messageType, message, context.file, context.line,
            context.function))
    else:
        print("{0}: {1}".format(messageType, message))