def main(): # create the Application app = QtWidgets.QApplication(sys.argv) # create the event loop event_loop = QEventLoop(app) asyncio.set_event_loop(event_loop) # Create the Gui main_window = MainWindow() # plugins to include different websites (and listeners?) plugin_manager = PluginManager() plugin_manager.register_main_window(main_window) # User Settings settings_manager = SettingsManager() settings_manager.register_main_window(main_window) settings_manager.register_plugin_manager(plugin_manager) main_window.show() try: event_loop.run_forever() except KeyboardInterrupt: pass app.deleteLater() plugin_manager.terminate_plugins() event_loop.close() sys.exit()
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(): 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 main(): # create the Application app = QtWidgets.QApplication(sys.argv) # create the event loop and set it in asyncio event_loop = QEventLoop(app) asyncio.set_event_loop(event_loop) # Create the Gui main_window = MainWindow() settings_data = main_window.settings_model.root # Create the recving messaging interface messager = ZmqMessaging() messager.message_signal.connect(main_window.chat_slot) messager.connected_signal.connect(main_window.status_bar.set_widget_status) main_window.command_line_signal.connect(messager.publish_message) # gather the plugins module_manager = pluginmanager.PluginInterface() module_manager.set_entry_points('chatimusmaximus.communication_protocols') modules, names = module_manager.collect_entry_point_plugins() # need to have the modules in a dict, so get the name and put in dict module_dict = {module.__name__.split('.')[-1]: module for module in modules} services, addresses = create_services_from_settings(settings_data, module_dict) atexit.register(_destroy_services, services) try: messager.subscribe_to_publishers(settings_data['sockets_to_connect_to']) cmd_line_address = settings_data['display']['address'] if cmd_line_address: messager.publish_to_address(cmd_line_address) except ZMQError: pass # show me the money! main_window.show() # let everything asyncorous run try: event_loop.run_forever() # catch ctrl-C event to allow for graceful closing except KeyboardInterrupt: pass # tell Qt we're going out app.deleteLater() # close the event loop event_loop.close() # close the subprocesses for service in services: service.deactivate() # exit sys.exit()
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(): # create the Application app = QtWidgets.QApplication(sys.argv) # create the event loop and set it in asyncio event_loop = QEventLoop(app) asyncio.set_event_loop(event_loop) # Create the Gui main_window = MainWindow() settings_data = main_window.settings_model.root # Need 3 bits of information from settings. ip addresses, display missing, # and general settings # Create the recving messaging interface messager = ZmqMessaging() messager.message_signal.connect(main_window.chat_slot) messager.connected_signal.connect(main_window.status_bar.set_widget_status) # gather the plugins module_manager = pluginmanager.PluginInterface() module_manager.set_entry_points('chatimusmaximus.communication_protocols') modules = module_manager.collect_entry_point_plugins() # need to have the modules in a dict, so get the name and put in dict module_dict = { module.__name__.split('.')[-1]: module for module in modules } services, addresses = create_services_from_settings( settings_data, module_dict) atexit.register(_destroy_services, services) messager.subscribe_to_publishers(settings_data['sockets_to_connect_to']) # show me the money! main_window.show() # let everything asyncorous run try: event_loop.run_forever() # catch ctrl-C event to allow for graceful closing except KeyboardInterrupt: pass # tell Qt we're going out app.deleteLater() # close the event loop event_loop.close() # close the subprocesses for service in services: service.deactivate() # exit sys.exit()
def main(): app = QApplication(sys.argv) loop = QEventLoop(app) asyncio.set_event_loop(loop) dialogo = AplicacionDescargaAnalisisAsync() dialogo.exec() with loop: loop.run_forever() loop.close() sys.exit(app.exec_())
def main(): app = QtWidgets.QApplication(sys.argv) # create the event loop and set it in asyncio event_loop = QEventLoop(app) asyncio.set_event_loop(event_loop) # login_window = QtWidgets.QMainWindow() ui = LoginWindow([getURL(), getWSURL()]) try: event_loop.run_forever() # catch ctrl-C event to allow for graceful closing except KeyboardInterrupt: pass app.deleteLater() event_loop.close() sys.exit()
def main(): # create the GUI app = QtWidgets.QApplication(sys.argv) # create the event loop event_loop = QEventLoop(app) asyncio.set_event_loop(event_loop) main_window = MainWindow() # need chat_slot to be able to add to add the chat signal chat_slot = main_window.central_widget.message_area.chat_slot settings = get_settings_helper() # this methods also handles passing in values to websites plugin_manager = instantiate_plugin_manager(settings) main_window.set_settings(settings) chat_list = plugin_manager.get_instances() # connect the sockets signals to the GUI for chat in chat_list: chat.chat_signal.connect(chat_slot) chat.connected_signal.connect(main_window.status_bar.set_widget_status) listener_interface = pluginmanager.PluginInterface() listener_interface.collect_plugins(plugins) listener_list = listener_interface.get_instances() # flake8: noqa # main_window.central_widget.message_area.listeners = listener_list main_window.show() try: event_loop.run_forever() except KeyboardInterrupt: pass for chat in chat_list: if chat.process: chat.process.terminate() event_loop.close() sys.exit()
def main(): # create the Application app = QtWidgets.QApplication(sys.argv) # create the event loop event_loop = QEventLoop(app) asyncio.set_event_loop(event_loop) # Create the Gui main_window = MainWindow() # plugins to include different websites (and listeners?) plugin_manager = PluginManager() plugin_manager.register_main_window(main_window) # User Settings settings_manager = SettingsManager() settings_manager.register_main_window(main_window) settings_manager.register_plugin_manager(plugin_manager) # listeners handeled separatly for now listener_interface = pluginmanager.PluginInterface() listener_interface.collect_plugins(plugins) listener_list = listener_interface.get_instances() # flake8: noqa # main_window.central_widget.message_area.listeners = listener_list main_window.show() try: event_loop.run_forever() except KeyboardInterrupt: pass app.deleteLater() plugin_manager.terminate_plugins() event_loop.close() sys.exit()
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())
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 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()
else: if self.camera_api is not None: stop_future = asyncio.ensure_future(self.camera_api.stopRecMode()) stop_future.add_done_callback(self.__pre_close_callback) event.ignore() else: logger.info("finished") app = QtWidgets.QApplication(sys.argv) loop = QEventLoop(app) loop.set_debug(False) asyncio.set_event_loop(loop) camera_remote = CameraRemote() camera_remote.show() logger = logging.getLogger("cameraremote") file_handler = logging.FileHandler(filename="cameraremote.log", mode='w') formatter = logging.Formatter("%(levelname)-8s %(message)s") file_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.setLevel(logging.DEBUG) logger.info("started") try: sys.exit(app.exec_()) finally: loop.close() file_handler.close()
def main(): # create the Application app = QtWidgets.QApplication(sys.argv) # create the event loop and set it in asyncio event_loop = QEventLoop(app) asyncio.set_event_loop(event_loop) # Create the Gui main_window = MainWindow() settings_data = main_window.settings_model.root # Create the recving messaging interface messager = ZmqMessaging() cmd_line_address = settings_data['display']['address'] if cmd_line_address: messager.publish_to_address(cmd_line_address) messager.message_signal.connect(main_window.chat_slot) messager.connected_signal.connect(main_window.status_bar.set_widget_status) clear = main_window.central_widget.message_area.clear messager.clear_signal.connect(clear) main_window.command_line_signal.connect(messager.publish_message) sockets = settings_data['sockets_to_connect_to'] cmd_line_address = settings_data['display']['address'] for socket in sockets: if socket: try: messager.subscribe_to_publisher(socket) except ZMQError: # TODO: change to a logging command s = 'socket address to connect to {} is throwing errors!' print(s.format(socket)) try: if cmd_line_address: messager.publish_to_address(cmd_line_address) except ZMQError: s = 'command line address to connect to {} is throwing errors!' print(s.format(cmd_line_address)) plugin_manager = pluginmanager.PluginInterface() plugin_manager.set_entry_points('chatimusmaximus.gui') # plugins, names plugins, _ = plugin_manager.collect_entry_point_plugins() for plug in plugins: plug(main_window, messager) # show me the money! main_window.show() # let everything asyncorous run try: event_loop.run_forever() # catch ctrl-C event to allow for graceful closing except KeyboardInterrupt: pass # tell Qt we're going out app.deleteLater() # close the event loop event_loop.close() # exit sys.exit()
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() #'''