def init_qtapp(): global qtapp, loop if qtapp is None: qtapp = QtWidgets.QApplication(sys.argv) loop = quamash.QEventLoop(qtapp) asyncio.set_event_loop(loop) return qtapp, loop
def _mainwindow(): app = QtWidgets.QApplication(sys.argv) loop = quamash.QEventLoop(app) asyncio.set_event_loop(loop) asyncio._set_running_loop(loop) with loop: obj = mainwindow.CMainWindow() QtWidgets.QApplication.setStyle( QtWidgets.QStyleFactory.create("Fusion")) palette = obj.palette() dPaletteInfo = { QtGui.QPalette.Base: (60, 58, 56), QtGui.QPalette.AlternateBase: (80, 80, 80), QtGui.QPalette.Window: (56, 56, 56), QtGui.QPalette.Text: (180, 180, 180), QtGui.QPalette.WindowText: (180, 180, 180), QtGui.QPalette.Button: (80, 80, 80), QtGui.QPalette.ButtonText: (180, 180, 180), QtGui.QPalette.Light: (80, 80, 80), QtGui.QPalette.Inactive: (150, 150, 150), QtGui.QPalette.Highlight: (150, 150, 150), } for oQT, tColor in dPaletteInfo.items(): palette.setColor(oQT, QtGui.QColor(*tColor)) obj.setPalette(palette) obj.show() loop.run_forever()
def loop(request, application): lp = quamash.QEventLoop(application) asyncio.set_event_loop(lp) additional_exceptions = [] def fin(): sys.excepthook = orig_excepthook try: lp.close() finally: asyncio.set_event_loop(None) for exc in additional_exceptions: if (os.name == 'nt' and isinstance(exc['exception'], WindowsError) and exc['exception'].winerror == 6): # ignore Invalid Handle Errors continue raise exc['exception'] def except_handler(loop, ctx): additional_exceptions.append(ctx) def excepthook(type, *args): lp.stop() orig_excepthook(type, *args) orig_excepthook = sys.excepthook sys.excepthook = excepthook lp.set_exception_handler(except_handler) request.addfinalizer(fin) return lp
def useQt(): """ Let the Qt event loop spin the asycio event loop. """ import PyQt5.Qt as qt import quamash if isinstance(asyncio.get_event_loop(), quamash.QEventLoop): return if not qt.QApplication.instance(): _qApp = qt.QApplication(sys.argv) loop = quamash.QEventLoop() asyncio.set_event_loop(loop) # fix the issue were run_until_complete does not work in Jupyter def run_until_complete(self, future): future = asyncio.ensure_future(future) def stop(*_args): self.stop() future.add_done_callback(stop) qApp = qt.QApplication.instance() try: self.run_forever() finally: future.remove_done_callback(stop) while (not future.done()): qApp.processEvents() if future.done(): break time.sleep(0.001) return future.result() quamash.QEventLoop.run_until_complete = run_until_complete
def main(): if sys.version_info < REQUIRED_PYTHON_VERSION: raise SystemExit("Python {}.{} or higher is required".format( REQUIRED_PYTHON_VERSION[0], REQUIRED_PYTHON_VERSION[1])) # QApplication.setAttribute(Qt.AA_ShareOpenGLContexts) app = Application(sys.argv) loop = quamash.QEventLoop(app) asyncio.set_event_loop(loop) pixmap = QPixmap('OptoStimLogo.jpeg') splash = QSplashScreen(pixmap) splash.show() w = OptoStimMainWindow() w.show() splash.finish(w) hook = ExceptHook(sentry_key=SENTRY_KEY, non_exit_exceptions=[DeviceException, OptoStimException]) sys.excepthook = hook.except_hook signal.signal(signal.SIGINT, w.clean_up) signal.signal(signal.SIGTERM, w.clean_up) try: with loop: sys.exit(loop.run_forever()) finally: w.clean_up()
def setUp(self): super(BackupTest, self).setUp() # mock up nonexistence of saved backup settings self.patcher_open = unittest.mock.patch('builtins.open') self.mock_open = self.patcher_open.start() self.mock_open.side_effect = FileNotFoundError() self.addCleanup(self.patcher_open.stop) # mock up the Backup Thread to avoid accidentally changing system state self.patcher_thread = unittest.mock.patch( 'qubesmanager.backup.BackupThread') self.mock_thread = self.patcher_thread.start() self.addCleanup(self.patcher_thread.stop) self.qapp = Qubes() self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"]) self.dispatcher = events.EventsDispatcher(self.qapp) self.loop = quamash.QEventLoop(self.qtapp) self.dialog = backup.BackupVMsWindow(self.qtapp, self.qapp, self.dispatcher) self.dialog.show()
def main(): qt_app = QtWidgets.QApplication(sys.argv) qt_app.setOrganizationName("The Qubes Project") qt_app.setOrganizationDomain("http://qubes-os.org") qt_app.setApplicationName("Qube Manager") qt_app.setWindowIcon(QtGui.QIcon.fromTheme("qubes-manager")) qt_app.lastWindowClosed.connect(loop_shutdown) qubes_app = Qubes() loop = quamash.QEventLoop(qt_app) asyncio.set_event_loop(loop) dispatcher = events.EventsDispatcher(qubes_app) manager_window = TemplateManagerWindow(qt_app, qubes_app, dispatcher) manager_window.show() try: loop.run_until_complete( asyncio.ensure_future(dispatcher.listen_for_events())) except asyncio.CancelledError: pass except Exception: # pylint: disable=broad-except loop_shutdown() exc_type, exc_value, exc_traceback = sys.exc_info()[:3] handle_exception(exc_type, exc_value, exc_traceback)
def main(): parser = argparse.ArgumentParser( description='Run a single task processor', formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('--host', '-H', dest='host', type=str, help='connect to host') parser.add_argument('--port', '-p', dest='port', type=int, help='port number') parser.add_argument('--unix_path', '-u', dest='unix_path', type=str, help='connect to Unix domain socket') parser.add_argument('--loop', '-l', dest='loop', default=0, type=int, help='0=default 1=asyncio 2=uvloop 3=proactor 4=quamash') args = parser.parse_args() if args.loop == LoopType.default: loop = util.get_loop() elif args.loop == LoopType.asyncio: loop = asyncio.get_event_loop() elif args.loop == LoopType.uvloop: import uvloop loop = uvloop.Loop() elif args.loop == LoopType.proactor: loop = asyncio.ProactorEventLoop() elif args.loop == LoopType.quamash: import quamash import PyQt5.Qt as qt _qapp = qt.QApplication([]) loop = quamash.QEventLoop() asyncio.set_event_loop(loop) processor = Processor(args.host, args.port, args.unix_path, loop=loop) loop.run_forever()
def main(): app = QApplication(sys.argv) loop = quamash.QEventLoop(app) asyncio.set_event_loop(loop) with loop: application = ClientApplication() application.setup(loop) sys.exit(app.exec())
def __init__(self, args: argparse.Namespace): self._args = args self._splash: T.Optional[QtWidgets.QSplashScreen] = None QtCore.pyqtRemoveInputHook() self._app = QtWidgets.QApplication(sys.argv) self._app.setApplicationName("bubblesub") self._loop = quamash.QEventLoop(self._app) asyncio.set_event_loop(self._loop)
def setUp(self): super(VMSettingsTest, self).setUp() self.mock_qprogress = unittest.mock.patch('PyQt4.QtGui.QProgressDialog') self.mock_qprogress.start() self.addCleanup(self.mock_qprogress.stop) self.qapp = Qubes() self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"]) self.loop = quamash.QEventLoop(self.qtapp)
def useQt(): """ Depreciated. """ import PyQt5.Qt as qt import quamash if isinstance(asyncio.get_event_loop(), quamash.QEventLoop): return assert qt.QApplication.instance() loop = quamash.QEventLoop() asyncio.set_event_loop(loop)
def setUp(self): super(GlobalSettingsTest, self).setUp() self.qapp = Qubes() self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"]) self.loop = quamash.QEventLoop(self.qtapp) self.dialog = global_settings.GlobalSettingsWindow(self.qtapp, self.qapp) self.setattr_patcher = unittest.mock.patch.object( type(self.dialog.qvm_collection), "__setattr__") self.setattr_mock = self.setattr_patcher.start() self.addCleanup(self.setattr_patcher.stop)
def setUpClass(cls): if not constants.TEST_OPTS.ALLOW_UI: return if cls.qt_app is None: cls.qt_app = QtWidgets.QApplication(['unittest']) cls.qt_app.setQuitOnLastWindowClosed(False) event_loop = quamash.QEventLoop(cls.qt_app) event_loop.set_exception_handler(error_handler) asyncio.set_event_loop(event_loop) executor = concurrent.futures.ThreadPoolExecutor(max_workers=10) event_loop.set_default_executor(executor)
def useQt(): """ Let the Qt event loop spin the asyncio event loop. """ import PyQt5.Qt as qt import quamash if isinstance(asyncio.get_event_loop(), quamash.QEventLoop): return if not qt.QApplication.instance(): _qApp = qt.QApplication(sys.argv) loop = quamash.QEventLoop() asyncio.set_event_loop(loop)
def useQt(): """ Integrate asyncio and Qt loops: Let the Qt event loop spin the asyncio event loop (does not work with nested event loops in Windows) """ import PyQt5.Qt as qt import quamash if isinstance(asyncio.get_event_loop(), quamash.QEventLoop): return assert qt.QApplication.instance() loop = quamash.QEventLoop() asyncio.set_event_loop(loop)
def main(): ''' Quamash is an Implementation of the PEP 3156 Event-Loop with Qt it is needed in order to run one event loop and plug all the asynchronous python function into it. This allows to run sockets, tasks and PyQt5 listening events inside signle event loop. ''' app = QApplication(sys.argv) loop = quamash.QEventLoop(app) asyncio.set_event_loop(loop) with loop: application = ClientApplication() client = Client(application, loop) sys.exit(app.exec())
def main(): parser = argparse.ArgumentParser() parser.add_argument("-v", dest="verbosity", action="count", default=0, help="Increase verbosity (up to -vvv)") parser.add_argument("--socket-path", default=None, type=pathlib.Path, help="Override the socket path " "(defaults to a user-specific socket)") args = parser.parse_args() logging.basicConfig(level={ 0: logging.ERROR, 1: logging.WARNING, 2: logging.INFO, }.get(args.verbosity, logging.DEBUG), ) if args.socket_path is None: args.socket_path = pathlib.Path( xdg.BaseDirectory.get_runtime_dir( strict=False)) / "cuteborg" / "scheduler.sock" logger = logging.getLogger("qtborg.trayicon") logging.getLogger("quamash").setLevel(logging.INFO) Qt.QApplication.setAttribute(Qt.Qt.AA_UseHighDpiPixmaps) app = Qt.QApplication(sys.argv[:1]) app.setQuitOnLastWindowClosed(False) asyncio.set_event_loop(quamash.QEventLoop(app=app)) loop = asyncio.get_event_loop() try: iconapp = Main(loop, logger, args.socket_path) rc = loop.run_until_complete(iconapp.run()) del iconapp del app import gc gc.collect() sys.exit(rc) finally: loop.close()
def main(): app = QApplication(sys.argv) asyncio.set_event_loop(quamash.QEventLoop(app)) @asyncio.coroutine def run(): core = core2.Core() window = gui.MainWindow(core) if not core.get_config('network.proxy'): if not window.configure_network(): return asyncio.get_event_loop().create_task(core.run()) window.show() asyncio.get_event_loop().create_task(run()) asyncio.get_event_loop().run_forever()
def __init__(self, app): super(MyWindow, self).__init__() self.setupUi(self) #初始化GUI self.loop = quamash.QEventLoop(app) # BLE协程循环 self.ble = BLE(self) # 实例化BLE self.emit_thread = EmitThread(self) # 实例化Emit对象 self.emit_thread.signal.connect(self.image) # 实时成像发射信号与槽函数连接 self.save_thread = saveThread(self) # 实例化save对象(连续测量10组实时数据) self.signal_slot() # 菜单栏的槽函数设置 self.alg = 'svd' # 默认调用灵敏度矩阵法 self.disp = 'interp' # 默认使用矩阵插值方式显示图像 self.refedata = np.zeros(28) # 空场参考值 self.projdata = np.zeros(28) # 历史测量值 self.proj_d = np.zeros(28) # 边界值差分(测量值-空场值) self.elem_data = np.zeros(576) # 图像重建数值 self.statusBar().showMessage('Ready') # 实例化MyFigure self.F = MyFigure(width=16, height=9, dpi=100) # ax1初始显示0 self.cache1 = self.F.ax1.bar(range(28), np.zeros(28), color='deepskyblue') # 鼠标移动显示当前位置的图像重建数值大小 plt.gcf().canvas.mpl_connect('motion_notify_event', self.motion_notify) # ax3初始显示为灰色 self.cache3 = [] for i in np.arange(8): for j in np.arange(i + 1, 8): cache, = self.F.ax3.plot([self.F.theta[i], self.F.theta[j]], [1, 1], color='dimgray') self.cache3.append(cache) plt.tight_layout() plt.ion() #进入交互成像模式 self.gridLayout.addWidget(self.F, 0, 1) #将画布置于GUI界面中
def main(): from PyQt5.QtWidgets import QApplication # from PyQt5.QtGui import QGuiApplication import quamash # setup application and quamash event-loop ## use module-level application reference to avoid crashes on exit ## (see http://pyqt.sourceforge.net/Docs/PyQt5/gotchas.html#crashes-on-exit) global app app = QApplication(sys.argv) loop = quamash.QEventLoop(app) asyncio.set_event_loop(loop) # initialize the main window from skymodman.interface.managerwindow import ModManagerWindow w = ModManagerWindow() # after creation of the window, create and assign the backend from skymodman.interface.qmodmanager import QModManager mmanager = QModManager() register_manager(mmanager) # perform setup of sub-managers mmanager.setup() # notify main window backend is ready w.manager_ready() # show the window w.show() # run the event loop try: with loop: loop.run_forever() finally: mmanager.DB.shutdown() log.stop_listener()
def run_asynchronous(window_class): qt_app = QtWidgets.QApplication(sys.argv) translator = QtCore.QTranslator(qt_app) locale = QtCore.QLocale.system().name() i18n_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'i18n') translator.load("qubesmanager_{!s}.qm".format(locale), i18n_dir) qt_app.installTranslator(translator) QtCore.QCoreApplication.installTranslator(translator) qt_app.setOrganizationName("The Qubes Project") qt_app.setOrganizationDomain("http://qubes-os.org") qt_app.lastWindowClosed.connect(loop_shutdown) qubes_app = qubesadmin.Qubes() loop = quamash.QEventLoop(qt_app) asyncio.set_event_loop(loop) dispatcher = events.EventsDispatcher(qubes_app) window = window_class(qt_app, qubes_app, dispatcher) if hasattr(window, "setup_application"): window.setup_application() window.show() try: loop.run_until_complete( asyncio.ensure_future(dispatcher.listen_for_events())) except asyncio.CancelledError: pass except Exception: # pylint: disable=broad-except loop_shutdown() exc_type, exc_value, exc_traceback = sys.exc_info()[:3] handle_exception(exc_type, exc_value, exc_traceback)
from timeit import default_timer logger = logging.getLogger(name=__name__) from . import APP # APP is only created once at the startup of PyRPL MAIN_THREAD = APP.thread() try: from asyncio import Future, ensure_future, CancelledError, \ set_event_loop, TimeoutError except ImportError: # this occurs in python 2.7 logger.debug("asyncio not found, we will use concurrent.futures " "instead of python 3.5 Futures.") from concurrent.futures import Future, CancelledError, TimeoutError else: import quamash set_event_loop(quamash.QEventLoop()) class MainThreadTimer(QtCore.QTimer): """ To be able to start a timer from any (eventually non Qt) thread, we have to make sure that the timer is living in the main thread (in Qt, each thread potentially has a distinct eventloop...). For example, this is required to use the timer within timeit. we might decide one day to allow 2 event loops to run concurrently in separate threads, but 1. That should be QThreads and not python threads 2. We would have to make sure that all the gui operations are performed in the main thread (for instance, by moving all widgets in the
# <http://www.gnu.org/licenses/>. # ######################################################################## import asyncio import gc import sys try: import quamash import PyQt5.Qt as Qt except ImportError as exc: print(exc, file=sys.stderr) print("This example requires quamash and PyQt5.", file=sys.stderr) from adhoc_browser.main import AdHocBrowser qapp = Qt.QApplication(sys.argv) qapp.setQuitOnLastWindowClosed(False) asyncio.set_event_loop(quamash.QEventLoop(app=qapp)) loop = asyncio.get_event_loop() try: example = AdHocBrowser() example.prepare_argparse() example.configure() loop.run_until_complete(example.run_example()) finally: loop.close() asyncio.set_event_loop(None) del example, loop, qapp gc.collect()
from controllers import MainWindowController from PyQt5 import QtWidgets import sys import asyncio import quamash qapp = QtWidgets.QApplication(sys.argv) loop = quamash.QEventLoop(qapp) asyncio.set_event_loop(loop) with loop: application = MainWindowController.MainWindowController() application.show() loop.run_forever() sys.exit(loop.stop())
def main(): import argparse parser = argparse.ArgumentParser() parser.add_argument("-V", "--version", action="store_true", default=False, help="Show version information and exit.") args = parser.parse_args() if args.version: print_version() sys.exit(0) app = Qt.QApplication(sys.argv) Qt.QResource.registerResource("resources.rcc") icon = Qt.QIcon() icon.addFile(":/icons/16x16/trayicon.png") icon.addFile(":/icons/24x24/trayicon.png") icon.addFile(":/icons/32x32/trayicon.png") app.setApplicationName("jabbercat") app.setApplicationDisplayName("JabberCat") app.setWindowIcon(icon) app.setQuitOnLastWindowClosed(False) import jabbercat.main logging.basicConfig( level=logging.DEBUG, format="%(asctime)-15s %(levelname)s:%(name)s: %(message)s") logging.getLogger("quamash").setLevel(logging.INFO) logging.getLogger("aioxmpp").setLevel(logging.DEBUG) logging.getLogger("aioxmpp.XMLStream").setLevel(logging.DEBUG) locale = Qt.QLocale.system().name() qttr = Qt.QTranslator(parent=app) if not qttr.load( "qt_" + locale, Qt.QLibraryInfo.location(Qt.QLibraryInfo.TranslationsPath)): logging.warning("failed to load Qt translations for %s", locale) else: app.installTranslator(qttr) qttr = Qt.QTranslator(parent=app) if not qttr.load("qttranslations/jabbercat_" + locale): logging.warning("failed to load JabberCat translations for %s", locale) else: app.installTranslator(qttr) asyncio.set_event_loop(quamash.QEventLoop(app=app)) loop = asyncio.get_event_loop() main = jabbercat.main.QtMain(loop) try: returncode = loop.run_until_complete(main.run()) finally: loop.close() # try very hard to evict parts from memory import gc gc.collect() del main gc.collect() del app asyncio.set_event_loop(None) del loop gc.collect() sys.exit(returncode)
def set_event_loop(): loop = quamash.QEventLoop(QtCore.QCoreApplication.instance()) asyncio.set_event_loop(loop) loop._QEventLoop__is_running = True
def main(): parser = argparse.ArgumentParser( description='Run a single task processor', formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('--host', '-H', dest='host', type=str, help='connect to host') parser.add_argument('--port', '-p', dest='port', type=int, help='port number') parser.add_argument('--unix_path', '-u', dest='unix_path', type=str, help='connect to Unix domain socket') parser.add_argument( '--loop', '-l', dest='loop', default=0, type=int, help='0=default 1=asyncio 2=uvloop 3=proactor 4=quamash') parser.add_argument('--func_pickle', '-f', dest='func_pickle', default=1, type=int, help='0=pickle 1=cloudpickle 2=dill') parser.add_argument('--data_pickle', '-d', dest='data_pickle', default=0, type=int, help='0=pickle 1=cloudpickle 2=dill') args = parser.parse_args() if not args.port and not args.unix_path: print('distex installed OK') return if args.loop == LoopType.default: loop = util.get_loop() elif args.loop == LoopType.asyncio: loop = asyncio.get_event_loop() elif args.loop == LoopType.uvloop: import uvloop loop = uvloop.Loop() elif args.loop == LoopType.proactor: loop = asyncio.ProactorEventLoop() elif args.loop == LoopType.quamash: import quamash import PyQt5.Qt as qt qapp = qt.QApplication([]) # noqa loop = quamash.QEventLoop() asyncio.set_event_loop(loop) processor = Processor( # noqa args.host, args.port, args.unix_path, args.func_pickle, args.data_pickle) loop.run_forever()
def setUp(self): super(BackupUtilsTest, self).setUp() self.qapp = Qubes() self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"]) self.loop = quamash.QEventLoop(self.qtapp)
def test_can_function_as_context_manager(application): """Verify that a QEventLoop can function as its own context manager.""" with quamash.QEventLoop(application) as loop: assert isinstance(loop, quamash.QEventLoop) loop.call_soon(loop.stop) loop.run_forever()