def main(): app = QApplication(sys.argv) #shared= QSharedMemory("wepush") #if shared.attach(): #return 0 #shared.create(1) #sys.stdout=common.Mystd() loop = QEventLoop(app) asyncio.set_event_loop(loop) win = QWebEngineView() # QWebEngineView() director['root_win'] = win #thread.start_new_thread (server.start_server,(28289,)) #win =QWebView() #win.setWindowIcon(QIcon( './html/wechat.ico')) win.setMinimumSize(1200, 900) win.setWindowTitle('微信群发工具V1.0') url = 'file:///%s/test.html' % base_dir.replace('\\', '/') win.load(QUrl(url)) win.show() with loop: from server import start_server #loop.set_debug(True) loop.run_until_complete(start_server) #loop.create_task(send()) #loop.create_task(start_server) loop.run_forever()
def main(): from quamash import QEventLoop, QtWidgets, QtCore from artiq import __artiq_dir__ as artiq_dir from concurrent.futures._base import CancelledError app = QtWidgets.QApplication(["Real Complicated Grapher"]) loop = QEventLoop(app) asyncio.set_event_loop(loop) class mainWindow(QtWidgets.QMainWindow): def __init__(self): QtWidgets.QMainWindow.__init__(self) icon = QtGui.QIcon( os.path.join(artiq_dir, "applets", "rcg", "rcg.svg")) self.setWindowIcon(icon) self.exit_request = asyncio.Event() self.setWindowTitle("Real Complicated Grapher") def closeEvent(self, event): event.ignore() self.exit_request.set() main_window = mainWindow() dock = rcgDock(main_window) dock.setFloating(False) main_window.addDockWidget(QtCore.Qt.TopDockWidgetArea, dock) main_window.show() try: loop.run_until_complete(main_window.exit_request.wait()) except CancelledError: # Don't understand this pass finally: loop.close()
def start_qt_app(config): import sys from PyQt5.QtWidgets import QApplication, QSystemTrayIcon, QMessageBox from quamash import QEventLoop from ui.main import Window from ui.qt_gui_connection import qSignal app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical(None, "Systray", "I couldn't detect any system tray on this system.") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) gui_connection = qSignal() window = Window(gui_connection) def closeApp(): print("Close app signal") for task in asyncio.Task.all_tasks(): print(task) task.cancel() loop.stop() gui_connection.closeApp.connect(closeApp) with loop: #asyncio.run_coroutine_threadsafe(timer(loop, config, gui_connection), loop) try: loop.run_until_complete(timer(loop, config, gui_connection)) except asyncio.CancelledError: pass
def main(): # initialize application args = get_argparser().parse_args() widget_log_handler = log.init_log(args, "browser") app = QtWidgets.QApplication(["ARTIQ Browser"]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) datasets_sub = models.LocalModelManager(datasets.Model) datasets_sub.init({}) smgr = state.StateManager(args.db_file) browser = Browser(smgr, datasets_sub, args.browse_root, args.server, args.port) widget_log_handler.callback = browser.log.append_message if os.name == "nt": # HACK: show the main window before creating applets. # Otherwise, the windows of those applets that are in detached # QDockWidgets fail to be embedded. browser.show() smgr.load() smgr.start() atexit_register_coroutine(smgr.stop) if args.select is not None: browser.files.select(args.select) browser.show() loop.run_until_complete(browser.exit_request.wait())
def main(self): connections = dict() users = dict() # Each client will create a new protocol instance self.ins = ChatServerProtocol(self.db_path, connections, users) # GUI app = Qt.QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) # NEW must set the event loop wnd = ServerMonitorWindow(server_instance=self.ins, parsed_args=self.args) wnd.show() with loop: coro = loop.create_server(lambda: self.ins, self.args["addr"], self.args["port"]) server = loop.run_until_complete(coro) # Serve requests until Ctrl+C print('Serving on {}:{}'.format(*server.sockets[0].getsockname())) try: loop.run_forever() except KeyboardInterrupt: pass server.close() loop.run_until_complete(server.wait_closed()) loop.close()
def main(): app = QtWidgets.QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) aw = ApplicationWindow() aw.show() loop.run_until_complete(amain(app, loop, aw)) loop.run_forever()
class SimpleApplet: def __init__(self, main_widget_class, cmd_description=None): self.main_widget_class = main_widget_class self.argparser = argparse.ArgumentParser(description=cmd_description) group = self.argparser.add_argument_group("data server") group.add_argument( "--server", default="::1", help="hostname or IP to connect to") group.add_argument( "--port", default=3250, type=int, help="TCP port to connect to") self._arggroup_datasets = self.argparser.add_argument_group("datasets") def add_dataset(self, name, help=None): if help is None: self._arggroup_datasets.add_argument(name) else: self._arggroup_datasets.add_argument(name, help=help) def args_init(self): self.args = self.argparser.parse_args() def quamash_init(self): app = QtWidgets.QApplication([]) self.loop = QEventLoop(app) asyncio.set_event_loop(self.loop) def create_main_widget(self): self.main_widget = self.main_widget_class(self.args) self.main_widget.show() def sub_init(self, data): self.data = data return data def sub_mod(self, mod): self.main_widget.data_changed(self.data, mod) def create_subscriber(self): self.subscriber = Subscriber("datasets", self.sub_init, self.sub_mod) self.loop.run_until_complete(self.subscriber.connect( self.args.server, self.args.port)) def run(self): self.args_init() self.quamash_init() try: self.create_main_widget() self.create_subscriber() try: self.loop.run_forever() finally: self.loop.run_until_complete(self.subscriber.close()) finally: self.loop.close()
def main() -> int: """ This is the main entry point of the application. We must import packages here, in the function, rather than globally, because the logging subsystem must be set up correctly at the import time. """ import atexit import asyncio import datetime from PyQt5.QtWidgets import QApplication from quamash import QEventLoop from . import data_dir, version, resources from .fuhrer import Fuhrer data_dir.init() # Only the main process will be logging into the file log_file_name = os.path.join( data_dir.LOG_DIR, f'{datetime.datetime.now():%Y%m%d-%H%M%S}-{os.getpid()}.log') file_handler = logging.FileHandler(log_file_name) file_handler.setLevel(LOGGING_LEVEL) file_handler.setFormatter( logging.Formatter( '%(asctime)s pid=%(process)-5d %(levelname)-8s %(name)s: %(message)s' )) logging.root.addHandler(file_handler) if '--profile' in sys.argv: try: # noinspection PyPep8Naming import cProfile as profile except ImportError: import profile def save_profile(): prof.disable() prof.dump_stats(log_file_name.replace('.log', '.pstat')) prof = profile.Profile() atexit.register(save_profile) prof.enable() # Configuring the event loop app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) # Running the application _logger.info('Starting version %r; package root: %r', version.__version__, resources.PACKAGE_ROOT) with loop: ctrl = Fuhrer() loop.run_until_complete(ctrl.run()) return 0
def main(): # initialize application args = get_argparser().parse_args() init_logger(args) app = QtWidgets.QApplication([]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) smgr = state.StateManager(args.db_file) datasets_sub = models.LocalModelManager(datasets.Model) # initialize main window main_window = MainWindow() smgr.register(main_window) status_bar = QtWidgets.QStatusBar() main_window.setStatusBar(status_bar) mdi_area = MdiArea() mdi_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) mdi_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) main_window.setCentralWidget(mdi_area) d_results = results.ResultsBrowser(datasets_sub) smgr.register(d_results) d_applets = applets.AppletsDock(main_window, datasets_sub) atexit_register_coroutine(d_applets.stop) smgr.register(d_applets) d_datasets = datasets.DatasetsDock(datasets_sub) smgr.register(d_datasets) main_window.setCentralWidget(d_results) main_window.addDockWidget(QtCore.Qt.BottomDockWidgetArea, d_applets) main_window.addDockWidget(QtCore.Qt.RightDockWidgetArea, d_datasets) # load/initialize state if os.name == "nt": # HACK: show the main window before creating applets. # Otherwise, the windows of those applets that are in detached # QDockWidgets fail to be embedded. main_window.show() smgr.load() if args.PATH: d_results.select(args.PATH) smgr.start() atexit_register_coroutine(smgr.stop) # run main_window.show() loop.run_until_complete(main_window.exit_request.wait())
def main(): app = QApplication([]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) win = MainWindow(app, None) container = QtWidgets.QWidget(win) layout = QtWidgets.QGridLayout() container.setLayout(layout) scanner = scanwidget.ScanWidget() layout.addWidget(scanner, 0, 0, 1, -1) spinboxes = [QtWidgets.QDoubleSpinBox(), QtWidgets.QDoubleSpinBox(), QtWidgets.QSpinBox()] for s in spinboxes: if type(s) is QtWidgets.QDoubleSpinBox: s.setDecimals(13) s.setMaximum(float("Inf")) s.setMinimum(float("-Inf")) else: s.setMinimum(1) s.setValue(10) for (col, w) in enumerate( [ QtWidgets.QLabel("Start"), spinboxes[0], QtWidgets.QLabel("Stop"), spinboxes[1], QtWidgets.QLabel("Points"), spinboxes[2], ] ): layout.addWidget(w, 1, col) scanner.sigMinMoved.connect(spinboxes[0].setValue) scanner.sigMaxMoved.connect(spinboxes[1].setValue) # scanner.sigNumChanged.connect(spinboxes[2].setValue) spinboxes[0].valueChanged.connect(scanner.setMin) spinboxes[1].valueChanged.connect(scanner.setMax) # spinboxes[2].valueChanged.connect(scanner.setNumPoints) win.setCentralWidget(container) win.show() scanner.fitToView() loop.run_until_complete(win.exit_request.wait())
class KnechtQT: def __init__(self, args): self.port = args.port self.address = args.listen self.app = None self.window = None self.loop = None def _close_window(self): if self.window: self.window.showNormal() self.window.hide() self.window.close() self.window = None def show_text(self, text, duration=None): if duration is None or duration <= 0: duration = 10 if self.window: self._close_window() try: subprocess.call(['xset', 'dpms', 'force', 'on']) except FileNotFoundError as e: pass label = QLabel() label.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter) label.setTextFormat(Qt.RichText) label.setWordWrap(True) label.setText('<span style="font-size:100px">%s</span>' % text) self.window = QMainWindow() self.window.setWindowTitle("KnechtQT") self.window.setCentralWidget(label) self.window.showFullScreen() self.loop.call_later(duration, self._close_window) def launch(self): self.app = QApplication([]) self.app.setQuitOnLastWindowClosed(False) self.loop = QEventLoop(self.app) asyncio.set_event_loop(self.loop) signal.signal(signal.SIGINT, signal.SIG_DFL) with self.loop: coro = self.loop.create_server(lambda: CommandReceiver(self), self.address, self.port) server = self.loop.run_until_complete(coro) self.loop.run_forever() server.close() loop.run_until_complete(server.wait_closed())
def main(): logging.basicConfig(level=logging.INFO) app = QApplication([]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) win = MainWindow(app, None) container = QtWidgets.QWidget(win) layout = QtWidgets.QGridLayout() container.setLayout(layout) scanner = ScanWidget() scanner.setFocusPolicy(QtCore.Qt.StrongFocus) layout.addWidget(scanner, 0, 0, -1, 1) spinbox = ScientificSpinBox() spinbox.setFocusPolicy(QtCore.Qt.StrongFocus) spinbox.setStyleSheet("QDoubleSpinBox {color:blue}") spinbox.setMinimumSize(110, 0) layout.addWidget(spinbox, 0, 1) scanner.startChanged.connect(spinbox.setValue) spinbox.valueChanged.connect(scanner.setStart) scanner.setStart(-100) spinbox = QtWidgets.QSpinBox() spinbox.setFocusPolicy(QtCore.Qt.StrongFocus) spinbox.setMinimum(1) spinbox.setMaximum((1 << 31) - 1) layout.addWidget(spinbox, 1, 1) scanner.numChanged.connect(spinbox.setValue) spinbox.valueChanged.connect(scanner.setNum) scanner.setNum(11) spinbox = ScientificSpinBox() spinbox.setFocusPolicy(QtCore.Qt.StrongFocus) spinbox.setStyleSheet("QDoubleSpinBox {color:red}") layout.addWidget(spinbox, 2, 1) scanner.stopChanged.connect(spinbox.setValue) spinbox.valueChanged.connect(scanner.setStop) scanner.setStop(200) win.setCentralWidget(container) win.show() loop.run_until_complete(win.exit_request.wait())
def main( argv ): # Setup the main event loop that will drive the chat client. app = ClientApp( argv ) main_loop = QEventLoop( app ) asyncio.set_event_loop( main_loop ) # Through a brilliant stroke of misfortune, it turns out on Windows the quamash library, which # provides the asyncio event loop that interops with Qt, derives from asyncio's ProactorEventLoop, # which does NOT support the creation of datagram (UDP) endpoints. If it were possible to change # the loop to one based on SelectorEventLoop, then UDP endpoints could be supported, but that's # outside my control. # # To avoid gutting the asynchronous code from the app and starting over with a different socket # API, we setup a separate thread to handle UDP traffic with a SelectorEventLoop. We then # communicate between the two event loops by submitting coroutines as tasks to the appropriate # event loop. It sucks and is ugly but better than rearchitecting late in the game. # datagram_channel_loop = asyncio.SelectorEventLoop( selectors.SelectSelector() ) datagram_channel_thread = DatagramChannelThread( datagram_channel_loop ) # Create the top-level app model state for the chat client. app_model = AppModel( main_loop, datagram_channel_thread ) cli = app.parse_command_line() app_model.screenName = cli.screen_name app_model.serverAddress = cli.server_address app_model.serverPort = cli.server_port # Initialize the UI. qmlRegisterUncreatableType( AppModel, "Chatter.Client", 1, 0, "AppModel", "AppModel cannot be craeted in QML." ) engine = QQmlApplicationEngine() engine.rootContext().setContextProperty( "appModel", app_model ) engine.load( "client.qml" ) with main_loop: datagram_channel_thread.start() main_loop.run_until_complete( app_model._client_stopped ) datagram_channel_thread.join() print( "Leaving app" )
def __init__(self, serial, printHz=False, bufsize=2048, baudrate=1e6): super().__init__() self.serial = serial self.baudrate = baudrate self.bufsize = bufsize self.run = True self.fs = 80000 self.c = 34300 # Filter parameters self.alpha = 0.05 self.cutoff = 100 self.order = 5 # Touch detection parameters self.threshold = 180.0 # Creating plot window app = QtGui.QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) self.resize(800, 400) # App ranges self.ranges = {'a': (20, 53), 'b': (62, 101), 'c': (110, 150)} # Plotting parameters p = self.addPlot() self.plotline = p.plot(pen='y') self.baseline = p.plot(pen='b') self.l = pg.TextItem() self.l.setText('') self.l.setColor('y') self.l.setTextWidth(500) p.addItem(self.l) self.show() loop.run_until_complete(self.read_data())
def main(): # initialize application args = get_argparser().parse_args() if args.db_file is None: args.db_file = os.path.join(get_user_config_dir(), "artiq_browser.pyon") widget_log_handler = log.init_log(args, "browser") app = QtWidgets.QApplication(["ARTIQ Browser"]) loop = QEventLoop(app) asyncio.set_event_loop(loop) # https://github.com/harvimt/quamash/issues/123 if sys.version_info >= (3, 8): asyncio.events._set_running_loop(loop) atexit.register(loop.close) datasets_sub = models.LocalModelManager(datasets.Model) datasets_sub.init({}) smgr = state.StateManager(args.db_file) browser = Browser(smgr, datasets_sub, args.browse_root, args.server, args.port) widget_log_handler.callback = browser.log.append_message if os.name == "nt": # HACK: show the main window before creating applets. # Otherwise, the windows of those applets that are in detached # QDockWidgets fail to be embedded. browser.show() smgr.load() smgr.start() atexit_register_coroutine(smgr.stop) if args.select is not None: browser.files.select(args.select) browser.show() loop.run_until_complete(browser.exit_request.wait())
def start_qt_app(config): import sys from PyQt5.QtWidgets import QApplication, QSystemTrayIcon, QMessageBox from quamash import QEventLoop from ui.main import Window from ui.qt_gui_connection import qSignal app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) if not QSystemTrayIcon.isSystemTrayAvailable(): QMessageBox.critical( None, "Systray", "I couldn't detect any system tray on this system.") sys.exit(1) QApplication.setQuitOnLastWindowClosed(False) gui_connection = qSignal() window = Window(gui_connection) def closeApp(): print("Close app signal") for task in asyncio.Task.all_tasks(): print(task) task.cancel() loop.stop() gui_connection.closeApp.connect(closeApp) with loop: #asyncio.run_coroutine_threadsafe(timer(loop, config, gui_connection), loop) try: loop.run_until_complete(timer(loop, config, gui_connection)) except asyncio.CancelledError: pass
def main(self): # create event loop app = Qt.QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) # NEW must set the event loop # authentication process auth_ = ClientAuth(db_path=self.db_path) login_wnd = LoginWindow(auth_instance=auth_) if login_wnd.exec_() == QtWidgets.QDialog.Accepted: # Each client will create a new protocol instance client_ = ChatClientProtocol(db_path=self.db_path, loop=loop, username=login_wnd.username, password=login_wnd.password) # create Contacts window wnd = ContactsWindow(client_instance=client_, user_name=login_wnd.username) client_.gui_instance = wnd # reference from protocol to GUI, for msg update with loop: # cleaning old instances del auth_ del login_wnd # connect to our server try: coro = loop.create_connection(lambda: client_, self.args["addr"], self.args["port"]) server = loop.run_until_complete(coro) except ConnectionRefusedError: print('Error. wrong server') exit(1) # start GUI client wnd.show() client_.get_from_gui() # asyncio.ensure_future(client_.get_from_gui(loop)) # Serve requests until Ctrl+C try: loop.run_forever() except KeyboardInterrupt: pass except Exception: pass
window = engine.rootObjects()[0] myObject = window.findChild(QObject, "myObject") #loop.call_soon(myObject.funcRetClicked()) #myObject.funcRetClicked() loop.run_in_executor(exec, myObject.funcRetClicked) ''' with loop: try: test = Test() service = Service(loop) #loop.run_forever() print('1') # rootObjects 실행전 context를 선언/추가해줍니다. ctx = engine.rootContext() ctx.setContextProperty('Service', service) #engine.load("main.qml") engine.load("qml/tytrader.qml") window = engine.rootObjects()[0] #window.setContextProperty('Service', service) loop.run_until_complete(test.printInterval()) loop.run_forever() except: pass
def main(): # initialize application args = get_argparser().parse_args() widget_log_handler = log.init_log(args, "dashboard") app = QtWidgets.QApplication(["ARTIQ Dashboard"]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) smgr = state.StateManager(args.db_file) # create connections to master rpc_clients = dict() for target in "schedule", "experiment_db", "dataset_db": client = AsyncioClient() loop.run_until_complete(client.connect_rpc(args.server, args.port_control, "master_" + target)) atexit.register(client.close_rpc) rpc_clients[target] = client sub_clients = dict() for notifier_name, modelf in ( ("explist", explorer.Model), ("explist_status", explorer.StatusUpdater), ("datasets", datasets.Model), ("schedule", schedule.Model), ): subscriber = ModelSubscriber(notifier_name, modelf) loop.run_until_complete(subscriber.connect(args.server, args.port_notify)) atexit_register_coroutine(subscriber.close) sub_clients[notifier_name] = subscriber log_receiver = Receiver("log", []) loop.run_until_complete(log_receiver.connect(args.server, args.port_broadcast)) atexit_register_coroutine(log_receiver.close) # initialize main window main_window = MainWindow(args.server) smgr.register(main_window) mdi_area = MdiArea() mdi_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) mdi_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) main_window.setCentralWidget(mdi_area) # create UI components expmgr = experiments.ExperimentManager( main_window, sub_clients["explist"], sub_clients["schedule"], rpc_clients["schedule"], rpc_clients["experiment_db"], ) smgr.register(expmgr) d_shortcuts = shortcuts.ShortcutsDock(main_window, expmgr) smgr.register(d_shortcuts) d_explorer = explorer.ExplorerDock( expmgr, d_shortcuts, sub_clients["explist"], sub_clients["explist_status"], rpc_clients["schedule"], rpc_clients["experiment_db"], ) smgr.register(d_explorer) d_datasets = datasets.DatasetsDock(sub_clients["datasets"], rpc_clients["dataset_db"]) smgr.register(d_datasets) d_applets = applets.AppletsDock(main_window, sub_clients["datasets"]) atexit_register_coroutine(d_applets.stop) smgr.register(d_applets) d_ttl_dds = moninj.MonInj() loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify)) atexit_register_coroutine(d_ttl_dds.stop) d_schedule = schedule.ScheduleDock(rpc_clients["schedule"], sub_clients["schedule"]) smgr.register(d_schedule) logmgr = log.LogDockManager(main_window) smgr.register(logmgr) log_receiver.notify_cbs.append(logmgr.append_message) widget_log_handler.callback = logmgr.append_message # lay out docks right_docks = [d_explorer, d_shortcuts, d_ttl_dds.ttl_dock, d_ttl_dds.dds_dock, d_datasets, d_applets] main_window.addDockWidget(QtCore.Qt.RightDockWidgetArea, right_docks[0]) for d1, d2 in zip(right_docks, right_docks[1:]): main_window.tabifyDockWidget(d1, d2) main_window.addDockWidget(QtCore.Qt.BottomDockWidgetArea, d_schedule) # load/initialize state if os.name == "nt": # HACK: show the main window before creating applets. # Otherwise, the windows of those applets that are in detached # QDockWidgets fail to be embedded. main_window.show() smgr.load() smgr.start() atexit_register_coroutine(smgr.stop) # create first log dock if not already in state d_log0 = logmgr.first_log_dock() if d_log0 is not None: main_window.tabifyDockWidget(d_schedule, d_log0) logging.info("ARTIQ dashboard %s connected to %s", artiq_version, args.server) # run main_window.show() loop.run_until_complete(main_window.exit_request.wait())
# some process #print('elapsed:{}'.format(self.elapsed)) if self.elapsed < 1: step = 1 - self.elapsed else : step = 1 #self.elapsed > 1 ? (step = 2 - self.elapsed) : step = 1 #print('step:{}'.format(step)) yield from asyncio.sleep(step) with loop: window = MyWindow(loop) #asyncio.async(window.initialize()) window.initialize() window.show() loop.run_until_complete(window.connect_and_timer()) #loop.run_until_complete(window.initialize()) #loop.call_soon(window.initialize()) loop.run_forever() ''' if __name__ == "__main__": QCoreApplication.setLibraryPaths([qt5_url]) #app = QApplication(sys.argv) window = MyWindows() window.show() #app.exec_() '''
def main(): # initialize application args = get_argparser().parse_args() init_logger(args) app = QtGui.QApplication([]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) smgr = state.StateManager(args.db_file) # create connections to master rpc_clients = dict() for target in "schedule", "experiment_db", "dataset_db": client = AsyncioClient() loop.run_until_complete(client.connect_rpc( args.server, args.port_control, "master_" + target)) atexit.register(client.close_rpc) rpc_clients[target] = client sub_clients = dict() for notifier_name, module in (("explist", explorer), ("datasets", datasets), ("schedule", schedule), ("log", log)): subscriber = ModelSubscriber(notifier_name, module.Model) loop.run_until_complete(subscriber.connect( args.server, args.port_notify)) atexit_register_coroutine(subscriber.close) sub_clients[notifier_name] = subscriber # initialize main window win = MainWindow(args.server) dock_area = dockarea.DockArea() smgr.register(dock_area) smgr.register(win) win.setCentralWidget(dock_area) status_bar = QtGui.QStatusBar() status_bar.showMessage("Connected to {}".format(args.server)) win.setStatusBar(status_bar) # create UI components expmgr = experiments.ExperimentManager(status_bar, dock_area, sub_clients["explist"], sub_clients["schedule"], rpc_clients["schedule"], rpc_clients["experiment_db"]) smgr.register(expmgr) d_shortcuts = shortcuts.ShortcutsDock(win, expmgr) smgr.register(d_shortcuts) d_explorer = explorer.ExplorerDock(status_bar, expmgr, d_shortcuts, sub_clients["explist"], rpc_clients["schedule"], rpc_clients["experiment_db"]) d_datasets = datasets.DatasetsDock(win, dock_area, sub_clients["datasets"]) smgr.register(d_datasets) if os.name != "nt": d_ttl_dds = moninj.MonInj() loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify)) atexit_register_coroutine(d_ttl_dds.stop) d_schedule = schedule.ScheduleDock( status_bar, rpc_clients["schedule"], sub_clients["schedule"]) logmgr = log.LogDockManager(dock_area, sub_clients["log"]) smgr.register(logmgr) d_console = console.ConsoleDock(sub_clients["datasets"], rpc_clients["dataset_db"]) # lay out docks if os.name != "nt": dock_area.addDock(d_ttl_dds.dds_dock, "top") dock_area.addDock(d_ttl_dds.ttl_dock, "above", d_ttl_dds.dds_dock) dock_area.addDock(d_datasets, "above", d_ttl_dds.ttl_dock) else: dock_area.addDock(d_datasets, "top") dock_area.addDock(d_shortcuts, "above", d_datasets) dock_area.addDock(d_explorer, "above", d_shortcuts) dock_area.addDock(d_console, "bottom") dock_area.addDock(d_schedule, "above", d_console) # load/initialize state smgr.load() smgr.start() atexit_register_coroutine(smgr.stop) # create first log dock if not already in state d_log0 = logmgr.first_log_dock() if d_log0 is not None: dock_area.addDock(d_log0, "right", d_explorer) # run win.show() loop.run_until_complete(win.exit_request.wait())
class SimpleApplet: def __init__(self, main_widget_class, cmd_description=None, default_update_delay=0.0): self.main_widget_class = main_widget_class self.argparser = argparse.ArgumentParser(description=cmd_description) self.argparser.add_argument( "--update-delay", type=float, default=default_update_delay, help="time to wait after a mod (buffering other mods) " "before updating (default: %(default).2f)") group = self.argparser.add_argument_group("standalone mode (default)") group.add_argument("--server", default="::1", help="hostname or IP of the master to connect to " "for dataset notifications " "(ignored in embedded mode)") group.add_argument("--port", default=3250, type=int, help="TCP port to connect to") self.argparser.add_argument("--embed", default=None, help="embed into GUI", metavar="IPC_ADDRESS") self._arggroup_datasets = self.argparser.add_argument_group("datasets") self.dataset_args = set() def add_dataset(self, name, help=None, required=True): kwargs = dict() if help is not None: kwargs["help"] = help if required: self._arggroup_datasets.add_argument(name, **kwargs) else: self._arggroup_datasets.add_argument("--" + name, **kwargs) self.dataset_args.add(name) def args_init(self): self.args = self.argparser.parse_args() self.datasets = { getattr(self.args, arg.replace("-", "_")) for arg in self.dataset_args } def quamash_init(self): app = QtWidgets.QApplication([]) self.loop = QEventLoop(app) asyncio.set_event_loop(self.loop) def ipc_init(self): if self.args.embed is not None: self.ipc = AppletIPCClient(self.args.embed) self.loop.run_until_complete(self.ipc.connect()) def ipc_close(self): if self.args.embed is not None: self.ipc.close() def create_main_widget(self): self.main_widget = self.main_widget_class(self.args) if self.args.embed is not None: self.ipc.set_close_cb(self.main_widget.close) if os.name == "nt": # HACK: if the window has a frame, there will be garbage # (usually white) displayed at its right and bottom borders # after it is embedded. self.main_widget.setWindowFlags(QtCore.Qt.FramelessWindowHint) self.main_widget.show() win_id = int(self.main_widget.winId()) self.loop.run_until_complete(self.ipc.embed(win_id)) else: # HACK: # Qt window embedding is ridiculously buggy, and empirical # testing has shown that the following procedure must be # followed exactly on Linux: # 1. applet creates widget # 2. applet creates native window without showing it, and # gets its ID # 3. applet sends the ID to host, host embeds the widget # 4. applet shows the widget # 5. parent resizes the widget win_id = int(self.main_widget.winId()) self.loop.run_until_complete(self.ipc.embed(win_id)) self.main_widget.show() self.ipc.fix_initial_size() else: self.main_widget.show() def sub_init(self, data): self.data = data return data def filter_mod(self, mod): if self.args.embed is not None: # the parent already filters for us return True if mod["action"] == "init": return True if mod["path"]: return mod["path"][0] in self.datasets elif mod["action"] in {"setitem", "delitem"}: return mod["key"] in self.datasets else: return False def emit_data_changed(self, data, mod_buffer): self.main_widget.data_changed(data, mod_buffer) def flush_mod_buffer(self): self.emit_data_changed(self.data, self.mod_buffer) del self.mod_buffer def sub_mod(self, mod): if not self.filter_mod(mod): return if self.args.update_delay: if hasattr(self, "mod_buffer"): self.mod_buffer.append(mod) else: self.mod_buffer = [mod] asyncio.get_event_loop().call_later(self.args.update_delay, self.flush_mod_buffer) else: self.emit_data_changed(self.data, [mod]) def subscribe(self): if self.args.embed is None: self.subscriber = Subscriber("datasets", self.sub_init, self.sub_mod) self.loop.run_until_complete( self.subscriber.connect(self.args.server, self.args.port)) else: self.ipc.subscribe(self.datasets, self.sub_init, self.sub_mod) def unsubscribe(self): if self.args.embed is None: self.loop.run_until_complete(self.subscriber.close()) def run(self): self.args_init() self.quamash_init() try: self.ipc_init() try: self.create_main_widget() self.subscribe() try: self.loop.run_forever() finally: self.unsubscribe() finally: self.ipc_close() finally: self.loop.close()
def main(): args = get_argparser().parse_args() init_logger(args) app = QtGui.QApplication([]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(lambda: loop.close()) smgr = StateManager(args.db_file) schedule_ctl = AsyncioClient() loop.run_until_complete(schedule_ctl.connect_rpc( args.server, args.port_control, "master_schedule")) atexit.register(lambda: schedule_ctl.close_rpc()) win = MainWindow(app, args.server) area = dockarea.DockArea() smgr.register(area) smgr.register(win) win.setCentralWidget(area) status_bar = QtGui.QStatusBar() status_bar.showMessage("Connected to {}".format(args.server)) win.setStatusBar(status_bar) d_explorer = ExplorerDock(win, status_bar, schedule_ctl) smgr.register(d_explorer) loop.run_until_complete(d_explorer.sub_connect( args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_explorer.sub_close())) d_datasets = DatasetsDock(win, area) smgr.register(d_datasets) loop.run_until_complete(d_datasets.sub_connect( args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_datasets.sub_close())) if os.name != "nt": d_ttl_dds = MonInj() loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_ttl_dds.stop())) if os.name != "nt": area.addDock(d_ttl_dds.dds_dock, "top") area.addDock(d_ttl_dds.ttl_dock, "above", d_ttl_dds.dds_dock) area.addDock(d_datasets, "above", d_ttl_dds.ttl_dock) else: area.addDock(d_datasets, "top") area.addDock(d_explorer, "above", d_datasets) d_schedule = ScheduleDock(status_bar, schedule_ctl) loop.run_until_complete(d_schedule.sub_connect( args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_schedule.sub_close())) d_log = LogDock() smgr.register(d_log) loop.run_until_complete(d_log.sub_connect( args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_log.sub_close())) dataset_db = AsyncioClient() loop.run_until_complete(dataset_db.connect_rpc( args.server, args.port_control, "master_dataset_db")) atexit.register(lambda: dataset_db.close_rpc()) def _set_dataset(k, v): asyncio.ensure_future(dataset_db.set(k, v)) def _del_dataset(k): asyncio.ensure_future(dataset_db.delete(k)) d_console = ConsoleDock( d_datasets.get_dataset, _set_dataset, _del_dataset) area.addDock(d_console, "bottom") area.addDock(d_log, "above", d_console) area.addDock(d_schedule, "above", d_log) smgr.load() smgr.start() atexit.register(lambda: loop.run_until_complete(smgr.stop())) win.show() loop.run_until_complete(win.exit_request.wait())
class WandGUI(): def __init__(self): self.args = args = get_argparser().parse_args() init_logger_from_args(args) if args.log_to_file: log_file = pkg_resources.resource_filename("wand", "log.txt") fh = logging.FileHandler(log_file, mode="wt") fh.setLevel(logger.getEffectiveLevel()) logger.addHandler(fh) logging.getLogger("quamash").addHandler(fh) sys.excepthook = lambda exc_type, exc_value, exc_traceback: \ logger.exception("".join( traceback.format_exception(exc_type, exc_value, exc_traceback))) self.config = load_config(args, "_gui") self.laser_db = {} self.freq_db = {} self.osa_db = {} self.subscribers = {} self.qapp = QtWidgets.QApplication(["WAnD"]) self.loop = QEventLoop(self.qapp) asyncio.set_event_loop(self.loop) atexit.register(self.loop.close) # set program icon icon = QtGui.QIcon() icon.addFile(pkg_resources.resource_filename("wand", "wand.svg")) self.qapp.setWindowIcon(icon) # create main window self.win = MainWindow() self.area = dock.DockArea() self.win.setCentralWidget(self.area) self.win.setWindowTitle("Super-duper Python Wavemeter Viewer!") # populate GUI self.laser_displays = {} for row in self.config["layout"]: prev = None pos = 'bottom' for display_name in row: display = LaserDisplay(display_name, self) self.laser_displays.update({display.laser: display}) self.area.addDock(display.dock, position=pos, relativeTo=prev) pos = 'right' prev = display.dock def notifier_cb(self, db, server, mod): """ Called whenever we get new data from a server "notifier" interface. NB sync_struct takes care of updating the relevant db for us, so all we do here is call the relevant GUI update function. """ if mod["action"] == "init": self.subscribers[server][db]["connected"] = True # check we're fully connected to the server before processing updates if (not self.subscribers[server]["laser_db"]["connected"] or not self.subscribers[server]["freq_db"]["connected"] or not self.subscribers[server]["osa_db"]["connected"]): return if mod["action"] == "init": # called when we first connect to a Notifier # we only activate the GUI channel for a laser once we have initial # data from all three Notifier interfaces (laser, freq, osa) displays = self.laser_displays for laser in mod["struct"].keys(): if laser not in self.laser_displays.keys(): continue if displays[laser].server not in [server, ""]: logger.error("laser '{}' found on multiple servers") displays.server = "" else: displays[laser].server = server displays[laser].wake_loop.set() elif mod["action"] == "setitem": if mod["path"] == []: laser = mod["key"] else: laser = mod["path"][0] if laser not in self.laser_displays.keys(): return if db == "freq_db": self.laser_displays[laser].update_freq() elif db == "osa_db": self.laser_displays[laser].update_osa_trace() elif db == "laser_db": if mod["key"] == "f_ref": self.laser_displays[laser].update_reference() elif (mod["key"] == "exposure" or (len(mod["path"]) > 1 and mod["path"][1] == "exposure")): self.laser_displays[laser].update_exposure() elif mod["key"] == "fast_mode": self.laser_displays[laser].update_fast_mode() elif mod["key"] == "auto_exposure": self.laser_displays[laser].update_auto_exposure() elif mod["key"] in ["locked", "lock_owner"]: self.laser_displays[laser].update_laser_status() else: raise ValueError("Unexpected notifier interface") else: raise ValueError( "Unexpected 'notifier' modification: {}".format(mod)) def start(self): """ Connect to the WaND servers """ def init_cb(db, mod): db.update(mod) return db async def subscriber_reconnect(self, server, db): logger.info("No connection to server '{}'".format(server)) for _, display in self.laser_displays.items(): if display.server == server: display.server = "" display.wake_loop.set() server_cfg = self.config["servers"][server] subscriber = self.subscribers[server][db]["subscriber"] if self.win.exit_request.is_set(): return def make_fut(self, server, db): fut = asyncio.ensure_future( subscriber_reconnect(self, server, db)) self.subscribers[server][db]["connected"] = False self.subscribers[server][db]["future"] = fut subscriber.disconnect_cb = functools.partial( make_fut, self, server, db) while not self.win.exit_request.is_set(): try: await subscriber.connect(server_cfg["host"], server_cfg["notify"]) logger.info("Reconnected to server '{}'".format(server)) break except OSError: logger.info( "could not connect to '{}' retry in 10s...".format( server)) await asyncio.sleep(10) for server, server_cfg in self.config["servers"].items(): self.subscribers[server] = {} # ask the servers to keep us updated with changes to laser settings # (exposures, references, etc) subscriber = Subscriber( "laser_db", functools.partial(init_cb, self.laser_db), functools.partial(self.notifier_cb, "laser_db", server)) fut = asyncio.ensure_future( subscriber_reconnect(self, server, "laser_db")) self.subscribers[server]["laser_db"] = { "subscriber": subscriber, "connected": False, "future": fut } # ask the servers to keep us updated with the latest frequency data subscriber = Subscriber( "freq_db", functools.partial(init_cb, self.freq_db), functools.partial(self.notifier_cb, "freq_db", server)) fut = asyncio.ensure_future( subscriber_reconnect(self, server, "freq_db")) self.subscribers[server]["freq_db"] = { "subscriber": subscriber, "connected": False, "future": fut } # ask the servers to keep us updated with the latest osa traces subscriber = Subscriber( "osa_db", functools.partial(init_cb, self.osa_db), functools.partial(self.notifier_cb, "osa_db", server)) fut = asyncio.ensure_future( subscriber_reconnect(self, server, "osa_db")) self.subscribers[server]["osa_db"] = { "subscriber": subscriber, "connected": False, "future": fut } atexit_register_coroutine(self.shutdown) self.win.showMaximized() atexit.register(self.win.exit_request.set) self.loop.run_until_complete(self.win.exit_request.wait()) async def shutdown(self): self.win.exit_request.set() for _, server in self.subscribers.items(): for _, subs_dict in server.items(): subs = subs_dict["subscriber"] fut = subs_dict["future"] try: await subs.close() except Exception: pass if fut is not None and not fut.done(): fut.cancel() for _, display in self.laser_displays.items(): display.fut.cancel()
while 1: if await dr.connect(): print("蓝牙连接成功......") break mAutoJoy = auto_joy.AutoJoy(dr, date_list_[0], date_list_[1], date_list_[2]) await mAutoJoy.run_in_gui() logger.info('Stopping communication...') await transport.close() if __name__ == '__main__': # check if root if not os.geteuid() == 0: raise PermissionError('Script must be run as root!') app = QApplication(sys.argv) mMainWindow = MainWindow() mMainWindow.show() loop = QEventLoop(app) asyncio.set_event_loop(loop) date_list_num = [2020, 3, 10] with loop: loop.run_until_complete(_main(date_list_num)) # start.
def main(): # initialize application args = get_argparser().parse_args() widget_log_handler = log.init_log(args, "dashboard") if args.db_file is None: args.db_file = os.path.join(get_user_config_dir(), "artiq_dashboard_{server}_{port}.pyon".format( server=args.server.replace(":","."), port=args.port_notify)) app = QtWidgets.QApplication(["ARTIQ Dashboard"]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) smgr = state.StateManager(args.db_file) # create connections to master rpc_clients = dict() for target in "schedule", "experiment_db", "dataset_db": client = AsyncioClient() loop.run_until_complete(client.connect_rpc( args.server, args.port_control, "master_" + target)) atexit.register(client.close_rpc) rpc_clients[target] = client config = Client(args.server, args.port_control, "master_config") try: server_name = config.get_name() finally: config.close_rpc() disconnect_reported = False def report_disconnect(): nonlocal disconnect_reported if not disconnect_reported: logging.error("connection to master lost, " "restart dashboard to reconnect") disconnect_reported = True sub_clients = dict() for notifier_name, modelf in (("explist", explorer.Model), ("explist_status", explorer.StatusUpdater), ("datasets", datasets.Model), ("schedule", schedule.Model)): subscriber = ModelSubscriber(notifier_name, modelf, report_disconnect) loop.run_until_complete(subscriber.connect( args.server, args.port_notify)) atexit_register_coroutine(subscriber.close) sub_clients[notifier_name] = subscriber broadcast_clients = dict() for target in "log", "ccb": client = Receiver(target, [], report_disconnect) loop.run_until_complete(client.connect( args.server, args.port_broadcast)) atexit_register_coroutine(client.close) broadcast_clients[target] = client # initialize main window main_window = MainWindow(args.server if server_name is None else server_name) smgr.register(main_window) mdi_area = MdiArea() mdi_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) mdi_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) main_window.setCentralWidget(mdi_area) # create UI components expmgr = experiments.ExperimentManager(main_window, sub_clients["explist"], sub_clients["schedule"], rpc_clients["schedule"], rpc_clients["experiment_db"]) smgr.register(expmgr) d_shortcuts = shortcuts.ShortcutsDock(main_window, expmgr) smgr.register(d_shortcuts) d_explorer = explorer.ExplorerDock(expmgr, d_shortcuts, sub_clients["explist"], sub_clients["explist_status"], rpc_clients["schedule"], rpc_clients["experiment_db"]) smgr.register(d_explorer) d_datasets = datasets.DatasetsDock(sub_clients["datasets"], rpc_clients["dataset_db"]) smgr.register(d_datasets) d_applets = applets_ccb.AppletsCCBDock(main_window, sub_clients["datasets"]) atexit_register_coroutine(d_applets.stop) smgr.register(d_applets) broadcast_clients["ccb"].notify_cbs.append(d_applets.ccb_notify) d_ttl_dds = moninj.MonInj() loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify)) atexit_register_coroutine(d_ttl_dds.stop) d_schedule = schedule.ScheduleDock( rpc_clients["schedule"], sub_clients["schedule"]) smgr.register(d_schedule) logmgr = log.LogDockManager(main_window) smgr.register(logmgr) broadcast_clients["log"].notify_cbs.append(logmgr.append_message) widget_log_handler.callback = logmgr.append_message # lay out docks right_docks = [ d_explorer, d_shortcuts, d_ttl_dds.ttl_dock, d_ttl_dds.dds_dock, d_ttl_dds.dac_dock, d_datasets, d_applets ] main_window.addDockWidget(QtCore.Qt.RightDockWidgetArea, right_docks[0]) for d1, d2 in zip(right_docks, right_docks[1:]): main_window.tabifyDockWidget(d1, d2) main_window.addDockWidget(QtCore.Qt.BottomDockWidgetArea, d_schedule) # load/initialize state if os.name == "nt": # HACK: show the main window before creating applets. # Otherwise, the windows of those applets that are in detached # QDockWidgets fail to be embedded. main_window.show() smgr.load() smgr.start() atexit_register_coroutine(smgr.stop) # create first log dock if not already in state d_log0 = logmgr.first_log_dock() if d_log0 is not None: main_window.tabifyDockWidget(d_schedule, d_log0) if server_name is not None: server_description = server_name + " ({})".format(args.server) else: server_description = args.server logging.info("ARTIQ dashboard %s connected to %s", artiq_version, server_description) # run main_window.show() loop.run_until_complete(main_window.exit_request.wait())
def main(): # initialize application args = get_argparser().parse_args() init_logger(args) app = QtWidgets.QApplication([]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) smgr = state.StateManager(args.db_file) # create connections to master rpc_clients = dict() for target in "schedule", "experiment_db", "dataset_db": client = AsyncioClient() loop.run_until_complete(client.connect_rpc( args.server, args.port_control, "master_" + target)) atexit.register(client.close_rpc) rpc_clients[target] = client sub_clients = dict() for notifier_name, module in (("explist", explorer), ("datasets", datasets), ("schedule", schedule), ("log", log)): subscriber = ModelSubscriber(notifier_name, module.Model) loop.run_until_complete(subscriber.connect( args.server, args.port_notify)) atexit_register_coroutine(subscriber.close) sub_clients[notifier_name] = subscriber # initialize main window main_window = MainWindow(args.server) smgr.register(main_window) status_bar = QtWidgets.QStatusBar() status_bar.showMessage("Connected to {}".format(args.server)) main_window.setStatusBar(status_bar) mdi_area = MdiArea() mdi_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) mdi_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) main_window.setCentralWidget(mdi_area) # create UI components expmgr = experiments.ExperimentManager(main_window, sub_clients["explist"], sub_clients["schedule"], rpc_clients["schedule"], rpc_clients["experiment_db"]) smgr.register(expmgr) d_shortcuts = shortcuts.ShortcutsDock(main_window, expmgr) smgr.register(d_shortcuts) d_explorer = explorer.ExplorerDock(status_bar, expmgr, d_shortcuts, sub_clients["explist"], rpc_clients["schedule"], rpc_clients["experiment_db"]) d_datasets = datasets.DatasetsDock(sub_clients["datasets"], rpc_clients["dataset_db"]) d_applets = applets.AppletsDock(main_window, sub_clients["datasets"]) atexit_register_coroutine(d_applets.stop) smgr.register(d_applets) if os.name != "nt": d_ttl_dds = moninj.MonInj() loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify)) atexit_register_coroutine(d_ttl_dds.stop) d_schedule = schedule.ScheduleDock( status_bar, rpc_clients["schedule"], sub_clients["schedule"]) logmgr = log.LogDockManager(main_window, sub_clients["log"]) smgr.register(logmgr) # lay out docks if os.name != "nt": main_window.addDockWidget(QtCore.Qt.RightDockWidgetArea, d_ttl_dds.dds_dock) main_window.tabifyDockWidget(d_ttl_dds.dds_dock, d_ttl_dds.ttl_dock) main_window.tabifyDockWidget(d_ttl_dds.ttl_dock, d_applets) main_window.tabifyDockWidget(d_applets, d_datasets) else: main_window.addDockWidget(QtCore.Qt.RightDockWidgetArea, d_applets) main_window.tabifyDockWidget(d_applets, d_datasets) main_window.tabifyDockWidget(d_datasets, d_shortcuts) main_window.addDockWidget(QtCore.Qt.BottomDockWidgetArea, d_schedule) main_window.addDockWidget(QtCore.Qt.LeftDockWidgetArea, d_explorer) # load/initialize state if os.name == "nt": # HACK: show the main window before creating applets. # Otherwise, the windows of those applets that are in detached # QDockWidgets fail to be embedded. main_window.show() smgr.load() smgr.start() atexit_register_coroutine(smgr.stop) # create first log dock if not already in state d_log0 = logmgr.first_log_dock() if d_log0 is not None: main_window.tabifyDockWidget(d_shortcuts, d_log0) # run main_window.show() loop.run_until_complete(main_window.exit_request.wait())
def main(): # initialize application args = get_argparser().parse_args() widget_log_handler = log.init_log(args, "dashboard") app = QtWidgets.QApplication(["ARTIQ Dashboard"]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) smgr = state.StateManager(args.db_file) # create connections to master rpc_clients = dict() for target in "schedule", "experiment_db", "dataset_db": client = AsyncioClient() loop.run_until_complete(client.connect_rpc( args.server, args.port_control, "master_" + target)) atexit.register(client.close_rpc) rpc_clients[target] = client sub_clients = dict() for notifier_name, modelf in (("explist", explorer.Model), ("explist_status", explorer.StatusUpdater), ("datasets", datasets.Model), ("schedule", schedule.Model)): subscriber = ModelSubscriber(notifier_name, modelf) loop.run_until_complete(subscriber.connect( args.server, args.port_notify)) atexit_register_coroutine(subscriber.close) sub_clients[notifier_name] = subscriber log_receiver = Receiver("log", []) loop.run_until_complete(log_receiver.connect( args.server, args.port_broadcast)) atexit_register_coroutine(log_receiver.close) # initialize main window main_window = MainWindow(args.server) smgr.register(main_window) mdi_area = MdiArea() mdi_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) mdi_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) main_window.setCentralWidget(mdi_area) # create UI components expmgr = experiments.ExperimentManager(main_window, sub_clients["explist"], sub_clients["schedule"], rpc_clients["schedule"], rpc_clients["experiment_db"]) smgr.register(expmgr) d_shortcuts = shortcuts.ShortcutsDock(main_window, expmgr) smgr.register(d_shortcuts) d_explorer = explorer.ExplorerDock(expmgr, d_shortcuts, sub_clients["explist"], sub_clients["explist_status"], rpc_clients["schedule"], rpc_clients["experiment_db"]) d_datasets = datasets.DatasetsDock(sub_clients["datasets"], rpc_clients["dataset_db"]) smgr.register(d_datasets) d_applets = applets.AppletsDock(main_window, sub_clients["datasets"]) atexit_register_coroutine(d_applets.stop) smgr.register(d_applets) d_ttl_dds = moninj.MonInj() loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify)) atexit_register_coroutine(d_ttl_dds.stop) d_schedule = schedule.ScheduleDock( rpc_clients["schedule"], sub_clients["schedule"]) smgr.register(d_schedule) logmgr = log.LogDockManager(main_window) smgr.register(logmgr) log_receiver.notify_cbs.append(logmgr.append_message) widget_log_handler.callback = logmgr.append_message # lay out docks right_docks = [ d_explorer, d_shortcuts, d_ttl_dds.ttl_dock, d_ttl_dds.dds_dock, d_datasets, d_applets ] main_window.addDockWidget(QtCore.Qt.RightDockWidgetArea, right_docks[0]) for d1, d2 in zip(right_docks, right_docks[1:]): main_window.tabifyDockWidget(d1, d2) main_window.addDockWidget(QtCore.Qt.BottomDockWidgetArea, d_schedule) # load/initialize state if os.name == "nt": # HACK: show the main window before creating applets. # Otherwise, the windows of those applets that are in detached # QDockWidgets fail to be embedded. main_window.show() smgr.load() smgr.start() atexit_register_coroutine(smgr.stop) # create first log dock if not already in state d_log0 = logmgr.first_log_dock() if d_log0 is not None: main_window.tabifyDockWidget(d_schedule, d_log0) logging.info("ARTIQ dashboard %s connected to %s", artiq_version, args.server) # run main_window.show() loop.run_until_complete(main_window.exit_request.wait())
''' with QThreadExecutor(1) as exec: window = engine.rootObjects()[0] myObject = window.findChild(QObject, "myObject") #loop.call_soon(myObject.funcRetClicked()) #myObject.funcRetClicked() loop.run_in_executor(exec, myObject.funcRetClicked) ''' with loop: try: test = Test() service = Service(loop) #loop.run_forever() print('1') # rootObjects 실행전 context를 선언/추가해줍니다. ctx = engine.rootContext() ctx.setContextProperty('Service', service) engine.load("main.qml") window = engine.rootObjects()[0] #window.setContextProperty('Service', service) loop.run_until_complete(test.printInterval()) loop.run_forever() except: pass
#print('step:{}'.format(step)) yield from asyncio.sleep(step) class Test(): def __init__(self, loop): pass pass with loop: window = MyWindow(loop) test = Test(loop) #asyncio.async(window.initialize()) window.initialize() window.show() loop.run_until_complete(window.connect_and_timer()) #loop.run_until_complete(window.initialize()) #loop.call_soon(window.initialize()) loop.run_forever() ''' if __name__ == "__main__": QCoreApplication.setLibraryPaths([qt5_url]) #app = QApplication(sys.argv) window = MyWindows() window.show() #app.exec_() '''
self.loop.run_until_complete(self.nats.master(loop)) try: self.loop.run_forever() finally: self.loop.close() if __name__ == '__main__': app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) # NEW must set the event loop ui = Me(loop) ui.show() # Example using NATS client from another thread. #thr = Thread(target=another_thread, args=(component,)) #thr.start() #tt = TestMyThread(ccc=loop) #tt.start() #''' with loop: ## context manager calls .close() when loop completes, and releases all resources loop.run_until_complete(ui.nats.master(loop)) # loop.run_until_complete(run(loop)) try: loop.run_forever() finally: loop.close() #'''
# bind Qt application with Python asyncio loop app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) g = app.desktop().screenGeometry() size = g.width() + 256 * 2, g.height() + 256 * 2 pos = (0, 0) if len(sys.argv) == 3: pos = float(sys.argv[1]), float(sys.argv[2]) mm = geotiler.Map(size=size, center=pos, zoom=18) window = MapWindow(mm) window.show() queue = asyncio.Queue() t1 = read_gps(queue) t2 = locate(window, queue) t3 = refresh_map(window) task = asyncio.gather(t1, t2, t3) window.refresh_map.set() loop.run_until_complete(task) # vim: sw=4:et:ai
async def process_events(qapp): while True: await asyncio.sleep(0) qapp.processEvents() if __name__ == "__main__": app = QApplication([]) if QUAMASH: from quamash import QEventLoop loop = QEventLoop(app) asyncio.set_event_loop(loop) else: loop = asyncio.get_event_loop() main = MainWindow(loop) loop.add_signal_handler(signal.SIGINT, main.shutdown, None) if QUAMASH: with loop: loop.run_forever() else: loop.run_until_complete(process_events(app)) app.closeAllWindows()
def main(): args = get_argparser().parse_args() init_logger(args) app = QtGui.QApplication([]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(lambda: loop.close()) smgr = StateManager(args.db_file) schedule_ctl = AsyncioClient() loop.run_until_complete( schedule_ctl.connect_rpc(args.server, args.port_control, "master_schedule")) atexit.register(lambda: schedule_ctl.close_rpc()) win = MainWindow(app, args.server) area = dockarea.DockArea() smgr.register(area) smgr.register(win) win.setCentralWidget(area) status_bar = QtGui.QStatusBar() status_bar.showMessage("Connected to {}".format(args.server)) win.setStatusBar(status_bar) d_explorer = ExplorerDock(win, status_bar, schedule_ctl) smgr.register(d_explorer) loop.run_until_complete( d_explorer.sub_connect(args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_explorer.sub_close())) d_datasets = DatasetsDock(win, area) smgr.register(d_datasets) loop.run_until_complete( d_datasets.sub_connect(args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_datasets.sub_close())) if os.name != "nt": d_ttl_dds = MonInj() loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_ttl_dds.stop())) if os.name != "nt": area.addDock(d_ttl_dds.dds_dock, "top") area.addDock(d_ttl_dds.ttl_dock, "above", d_ttl_dds.dds_dock) area.addDock(d_datasets, "above", d_ttl_dds.ttl_dock) else: area.addDock(d_datasets, "top") area.addDock(d_explorer, "above", d_datasets) d_schedule = ScheduleDock(status_bar, schedule_ctl) loop.run_until_complete( d_schedule.sub_connect(args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_schedule.sub_close())) d_log = LogDock() smgr.register(d_log) loop.run_until_complete(d_log.sub_connect(args.server, args.port_notify)) atexit.register(lambda: loop.run_until_complete(d_log.sub_close())) dataset_db = AsyncioClient() loop.run_until_complete( dataset_db.connect_rpc(args.server, args.port_control, "master_dataset_db")) atexit.register(lambda: dataset_db.close_rpc()) def _set_dataset(k, v): asyncio.ensure_future(dataset_db.set(k, v)) def _del_dataset(k): asyncio.ensure_future(dataset_db.delete(k)) d_console = ConsoleDock(d_datasets.get_dataset, _set_dataset, _del_dataset) area.addDock(d_console, "bottom") area.addDock(d_log, "above", d_console) area.addDock(d_schedule, "above", d_log) smgr.load() smgr.start() atexit.register(lambda: loop.run_until_complete(smgr.stop())) win.show() loop.run_until_complete(win.exit_request.wait())
scroll_map(self, self.position) # bind Qt application with Python asyncio loop app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) g = app.desktop().screenGeometry() size = g.width() + 256 * 2, g.height() + 256 * 2 pos = (0, 0) if len(sys.argv) == 3: pos = float(sys.argv[1]), float(sys.argv[2]) mm = geotiler.Map(size=size, center=pos, zoom=18) window = MapWindow(mm) window.show() queue = asyncio.Queue() t1 = read_gps(queue) t2 = locate(window, queue) t3 = refresh_map(window) task = asyncio.gather(t1, t2, t3) window.refresh_map.set() loop.run_until_complete(task) # vim: sw=4:et:ai
from widgets.main import Main from service.util import open_session,close_session if __name__ == "__main__": """ 在PyQt5中,如果在Python 代码中抛出了异常,没有进行捕获,异常只要进入事件循环,程序就崩溃,而没有任何提示,给程序调试带来不少麻烦,通过在程序运行前加入以下代码,则能避免程序崩溃. import cgitb cgitb.enable( format = ‘text’) """ import sys import qdarkstyle import cgitb cgitb.enable(format='text')# app = QApplication(sys.argv) # 将Qt事件循环写到asyncio事件循环里。 # QEventLoop不是Qt原生事件循环, # 是被asyncio重写的事件循环。 loop = QEventLoop(app) asyncio.set_event_loop(loop) with loop: Form = Main() loop.run_until_complete(open_session()) app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5()) Form.initUI() Form.resize(1022, 700) #Form.resize(600, 400) Form.show() #sys.exit(app.exec_()) loop.run_forever() loop.run_until_complete(close_session()) #print("close")
self.discovered = True def _fullpath(self, join=None): p = [self.name] target = self._parent() while target: p.append(target.name) target = target.parent() p.reverse() if join is not None: return join.join(p) return p async def main(): await asyncio.wait([ slow_operation(1), slow_operation(2), slow_operation(3), ]) app = QtGui.QApplication([]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) #loop = asyncio.get_event_loop() win = MainWindow(app, None) win.show() loop.run_until_complete(win.exit_request.wait()) loop.run_until_complete(main())
def wire_tap(msg): ex.insertText(msg.data.decode()) def main(loop, subject): nc = NATS() yield from nc.connect(f"{sys.argv[1]}:{sys.argv[2]}", loop=loop) async def mh_s1(msg): await wire_tap(msg) yield from nc.subscribe(subject, cb=wire_tap) if __name__ == '__main__': if len(sys.argv) != 4: print( "Usage: python nats_scrolling_plaintext_edit.py [host] [port] [queue]" ) else: app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) loop.run_until_complete(main(loop, subject=sys.argv[3])) ex = QtWiretap() loop.run_forever()
class BadgecmdMainWindow(QMainWindow, Ui_MainWindow): def __init__(self, app, device, baudrate): QMainWindow.__init__(self) Ui_MainWindow.__init__(self) self.device = device self.baudrate = baudrate self.app = app self.setupUi(self) self.setWindowTitle('Badgecmd') self.main_loop = QEventLoop(self.app) asyncio.set_event_loop(self.main_loop) self.io = IoSignals() self.proto = BadgeProtocol(self.io) self.serial_coro = None self.awaiting = None self.paused = False # connect all of the signals for method in self.__dir__(): if method.startswith('_when_'): emitter_name, signal_name = method.split('_')[-2:] signal = getattr(getattr(self, emitter_name), signal_name) signal.connect(getattr(self, method)) def _serial_connect(self): if not self.serial_coro: self.serial_coro = create_serial_connection( self.main_loop, self.proto, self.device, # baudrate=9600 baudrate=self.baudrate) self.main_loop.run_until_complete(self.serial_coro) def _serial_disconnect(self): if self.serial_coro: self.proto.close() self.serial_coro = None def _when_clear_clicked(self): self.output.clear() def _when_connect_clicked(self): if self.connect.text() == 'connect': self._serial_connect() self.connect.setText('disconnect') self.pause.setText('pause') self.paused = False else: self._serial_disconnect() self.connect.setText('connect') def _when_io_disconnect(self): self.connect.setText('connect') def _when_io_rx(self, packet): # if packet.command == 0xAF and packet.slave_reply == 0: # logging.warn('skipping 0xAF') # return if self.paused: return if self.awaiting == packet.command and packet.slave_reply: self.output.setTextColor(qGreen) self.awaiting = None else: self.output.setTextColor(qBlue) self.output.append(' '.join([ 'rx:', repr(packet), ','.join(["0x{:02X}".format(i) for i in packet.to_bytes()]) ])) self.output.setTextColor(qBlack) def _when_input_returnPressed(self): raw = self.input.text() if len(raw): try: data = [int(i, 16) for i in raw.split(' ')] except ValueError as e: logging.error(e) return packet = Packet(command=data[0], data=data[1:], include_checksum=self.crc.isChecked(), slave_reply=self.mode.text() == 'S') packet_bytes = packet.to_bytes() if self.mode.text() == 'M': self.awaiting = packet.command self.proto.send(packet_bytes) self.output.setTextColor(qRed) self.output.append(' '.join([ 'tx:', repr(packet), ','.join(["0x{:02X}".format(i) for i in packet_bytes]) ])) self.output.setTextColor(qBlack) def _when_mode_clicked(self): if self.mode.text() == 'M': self.mode.setText('S') else: self.mode.setText('M') def _when_pause_clicked(self): if self.pause.text() == 'pause': self.pause.setText('unpause') self.paused = True # self.proto.pause() else: self.pause.setText('pause') self.paused = False # self.proto.unpause() def exec_(self): return self.main_loop.run_forever()
def main(): # initialize application args = get_argparser().parse_args() widget_log_handler = log.init_log(args, "dashboard") if args.db_file is None: args.db_file = os.path.join( get_user_config_dir(), "artiq_dashboard_{server}_{port}.pyon".format( server=args.server.replace(":", "."), port=args.port_notify)) app = QtWidgets.QApplication(["ARTIQ Dashboard"]) loop = QEventLoop(app) asyncio.set_event_loop(loop) atexit.register(loop.close) smgr = state.StateManager(args.db_file) # create connections to master rpc_clients = dict() for target in "schedule", "experiment_db", "dataset_db": client = AsyncioClient() loop.run_until_complete( client.connect_rpc(args.server, args.port_control, "master_" + target)) atexit.register(client.close_rpc) rpc_clients[target] = client config = Client(args.server, args.port_control, "master_config") try: server_name = config.get_name() finally: config.close_rpc() disconnect_reported = False def report_disconnect(): nonlocal disconnect_reported if not disconnect_reported: logging.error("connection to master lost, " "restart dashboard to reconnect") disconnect_reported = True sub_clients = dict() for notifier_name, modelf in (("explist", explorer.Model), ("explist_status", explorer.StatusUpdater), ("datasets", datasets.Model), ("schedule", schedule.Model)): subscriber = ModelSubscriber(notifier_name, modelf, report_disconnect) loop.run_until_complete( subscriber.connect(args.server, args.port_notify)) atexit_register_coroutine(subscriber.close) sub_clients[notifier_name] = subscriber broadcast_clients = dict() for target in "log", "ccb": client = Receiver(target, [], report_disconnect) loop.run_until_complete( client.connect(args.server, args.port_broadcast)) atexit_register_coroutine(client.close) broadcast_clients[target] = client # initialize main window main_window = MainWindow( args.server if server_name is None else server_name) smgr.register(main_window) mdi_area = MdiArea() mdi_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) mdi_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAsNeeded) main_window.setCentralWidget(mdi_area) # create UI components expmgr = experiments.ExperimentManager(main_window, sub_clients["explist"], sub_clients["schedule"], rpc_clients["schedule"], rpc_clients["experiment_db"]) smgr.register(expmgr) d_shortcuts = shortcuts.ShortcutsDock(main_window, expmgr) smgr.register(d_shortcuts) d_explorer = explorer.ExplorerDock(expmgr, d_shortcuts, sub_clients["explist"], sub_clients["explist_status"], rpc_clients["schedule"], rpc_clients["experiment_db"]) smgr.register(d_explorer) d_datasets = datasets.DatasetsDock(sub_clients["datasets"], rpc_clients["dataset_db"]) smgr.register(d_datasets) d_applets = applets_ccb.AppletsCCBDock(main_window, sub_clients["datasets"]) atexit_register_coroutine(d_applets.stop) smgr.register(d_applets) broadcast_clients["ccb"].notify_cbs.append(d_applets.ccb_notify) d_ttl_dds = moninj.MonInj() loop.run_until_complete(d_ttl_dds.start(args.server, args.port_notify)) atexit_register_coroutine(d_ttl_dds.stop) d_schedule = schedule.ScheduleDock(rpc_clients["schedule"], sub_clients["schedule"]) smgr.register(d_schedule) logmgr = log.LogDockManager(main_window) smgr.register(logmgr) broadcast_clients["log"].notify_cbs.append(logmgr.append_message) widget_log_handler.callback = logmgr.append_message # lay out docks right_docks = [ d_explorer, d_shortcuts, d_ttl_dds.ttl_dock, d_ttl_dds.dds_dock, d_ttl_dds.dac_dock, d_datasets, d_applets ] main_window.addDockWidget(QtCore.Qt.RightDockWidgetArea, right_docks[0]) for d1, d2 in zip(right_docks, right_docks[1:]): main_window.tabifyDockWidget(d1, d2) main_window.addDockWidget(QtCore.Qt.BottomDockWidgetArea, d_schedule) # load/initialize state if os.name == "nt": # HACK: show the main window before creating applets. # Otherwise, the windows of those applets that are in detached # QDockWidgets fail to be embedded. main_window.show() smgr.load() smgr.start() atexit_register_coroutine(smgr.stop) # create first log dock if not already in state d_log0 = logmgr.first_log_dock() if d_log0 is not None: main_window.tabifyDockWidget(d_schedule, d_log0) if server_name is not None: server_description = server_name + " ({})".format(args.server) else: server_description = args.server logging.info("ARTIQ dashboard %s connected to %s", artiq_version, server_description) # run main_window.show() loop.run_until_complete(main_window.exit_request.wait())
def __init__(self, serialport, *, baudrate=115200, outpath=None, printlines=False, firstline='', printHz=False, bufsize=2048, pMin=0, pMax=25, convert_pressure=False, socket_start=False): super().__init__() self.serialport = serialport self.baudrate = baudrate self.outpath = outpath self.outfile = None self.printlines = printlines self.printHz = printHz self.bufsize = bufsize self.plotbuf = deque(maxlen=self.bufsize) self.rawdata = deque(maxlen=self.bufsize) self.pMin = pMin self.pMax = pMax self.convert_pressure = convert_pressure self.f = OneEuroFilter(100, .25, .1) self.event = 0 self.run = True self.filterflag = True #Touch event detection self.diffsamps = 100 #How far back to look for diff self.event_thresh = 7 #Standard Deviation value to consider an event is happening self.touch = False #Is a touch happening? self.touchcount = 0 #How many touch samples so far? self.touchthresh = 1000 #Number of touch samples to check self.touch_data = [ ] #Data from touch to be sent to machine learning thingy self.touch_buf = [] # self.model = load(model) # Path to compiled model file self.printed = False self.socket = socket_start #Keep values to update baseline self.baselinebuf = deque(maxlen=self.bufsize // 4) app = QtGui.QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) self.resize(800, 400) p = self.addPlot() self.plotline = p.plot(pen='y') self.baseline = p.plot(pen='b') self.show() if self.socket: # Create socket and wait for connection ip = '' port = 6969 connected = False s = socket.socket() print('Waiting on connection') s.bind((ip, port)) s.listen(1) self.conn, self.addr = s.accept() loop.run_until_complete(self.read_data()) if self.outpath: with open(self.outpath, 'w') as self.outfile: if firstline: self.log('#{}'.format(firstline)) loop.run_until_complete(self.read_data()) else: if firstline: self.log('#{}'.format(firstline)) loop.run_until_complete(self.read_data())
class SimpleApplet: def __init__(self, main_widget_class, cmd_description=None, default_update_delay=0.0): self.main_widget_class = main_widget_class self.argparser = argparse.ArgumentParser(description=cmd_description) self.argparser.add_argument( "--update-delay", type=float, default=default_update_delay, help="time to wait after a mod (buffering other mods) " "before updating (default: %(default).2f)") group = self.argparser.add_argument_group("standalone mode (default)") group.add_argument( "--server", default="::1", help="hostname or IP of the master to connect to " "for dataset notifications " "(ignored in embedded mode)") group.add_argument( "--port", default=3250, type=int, help="TCP port to connect to") self.argparser.add_argument( "--embed", default=None, help="embed into GUI", metavar="IPC_ADDRESS") self._arggroup_datasets = self.argparser.add_argument_group("datasets") self.dataset_args = set() def add_dataset(self, name, help=None, required=True): kwargs = dict() if help is not None: kwargs["help"] = help if required: self._arggroup_datasets.add_argument(name, **kwargs) else: self._arggroup_datasets.add_argument("--" + name, **kwargs) self.dataset_args.add(name) def args_init(self): self.args = self.argparser.parse_args() self.datasets = {getattr(self.args, arg.replace("-", "_")) for arg in self.dataset_args} def quamash_init(self): app = QtWidgets.QApplication([]) self.loop = QEventLoop(app) asyncio.set_event_loop(self.loop) def ipc_init(self): if self.args.embed is not None: self.ipc = AppletIPCClient(self.args.embed) self.loop.run_until_complete(self.ipc.connect()) def ipc_close(self): if self.args.embed is not None: self.ipc.close() def create_main_widget(self): self.main_widget = self.main_widget_class(self.args) if self.args.embed is not None: self.ipc.set_close_cb(self.main_widget.close) if os.name == "nt": # HACK: if the window has a frame, there will be garbage # (usually white) displayed at its right and bottom borders # after it is embedded. self.main_widget.setWindowFlags(QtCore.Qt.FramelessWindowHint) self.main_widget.show() win_id = int(self.main_widget.winId()) self.loop.run_until_complete(self.ipc.embed(win_id)) else: # HACK: # Qt window embedding is ridiculously buggy, and empirical # testing has shown that the following procedure must be # followed exactly on Linux: # 1. applet creates widget # 2. applet creates native window without showing it, and # gets its ID # 3. applet sends the ID to host, host embeds the widget # 4. applet shows the widget # 5. parent resizes the widget win_id = int(self.main_widget.winId()) self.loop.run_until_complete(self.ipc.embed(win_id)) self.main_widget.show() self.ipc.fix_initial_size() else: self.main_widget.show() def sub_init(self, data): self.data = data return data def filter_mod(self, mod): if self.args.embed is not None: # the parent already filters for us return True if mod["action"] == "init": return True if mod["path"]: return mod["path"][0] in self.datasets elif mod["action"] in {"setitem", "delitem"}: return mod["key"] in self.datasets else: return False def emit_data_changed(self, data, mod_buffer): self.main_widget.data_changed(data, mod_buffer) def flush_mod_buffer(self): self.emit_data_changed(self.data, self.mod_buffer) del self.mod_buffer def sub_mod(self, mod): if not self.filter_mod(mod): return if self.args.update_delay: if hasattr(self, "mod_buffer"): self.mod_buffer.append(mod) else: self.mod_buffer = [mod] asyncio.get_event_loop().call_later(self.args.update_delay, self.flush_mod_buffer) else: self.emit_data_changed(self.data, [mod]) def subscribe(self): if self.args.embed is None: self.subscriber = Subscriber("datasets", self.sub_init, self.sub_mod) self.loop.run_until_complete(self.subscriber.connect( self.args.server, self.args.port)) else: self.ipc.subscribe(self.datasets, self.sub_init, self.sub_mod) def unsubscribe(self): if self.args.embed is None: self.loop.run_until_complete(self.subscriber.close()) def run(self): self.args_init() self.quamash_init() try: self.ipc_init() try: self.create_main_widget() self.subscribe() try: self.loop.run_forever() finally: self.unsubscribe() finally: self.ipc_close() finally: self.loop.close()
progress = QProgressBar() progress.setRange(0, 99) progress.show() @asyncio.coroutine def master(): yield from first_50() with QThreadExecutor(1) as exec: yield from loop.run_in_executor(exec, last_50) @asyncio.coroutine def first_50(): for i in range(50): progress.setValue(i) yield from asyncio.sleep(.1) def last_50(): for i in range(50, 100): loop.call_soon_threadsafe(progress.setValue, i) time.sleep(.1) with loop: loop.run_until_complete(master())