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