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()
#'''
