def main(): if is_manager_dbus_running(): return app = QtCore.QCoreApplication(sys.argv) app.setApplicationName(_(constants.APP_NAME)) manager_dbus = ManagerDBus() app.exec()
def main(): args = parse_args() # Try to connect to the GPU backend app = QtCore.QCoreApplication([]) # Start the GPU backend cmdline = [GPUSIM_EXEC] if args.cpu_only: cmdline.append('--cpu_only') cmdline += ['--gpu_bitcount', args.gpu_bitcount] cmdline += args.dbnames backend_proc = subprocess.Popen(cmdline) setup_socket(app) if args.http_interface: handler = GPUSimHTTPHandler else: handler = GPUSimHandler server = ThreadedHTTPServer((args.hostname, args.port), handler) print("Running HTTP server...", file=sys.stderr) try: server.serve_forever() finally: backend_proc.kill()
def current(session: Session): """ Retrieve the checked-in User instance. If the User doesn't exist in the sessions database, and there isn't a conflict, this method will create it. """ app = QtCore.QCoreApplication.instance() or QtCore.QCoreApplication(sys.argv) settings = QtCore.QSettings(ORG_NAME, APP_NAME) name = settings.value('User.name', None) uid = settings.value('User.uid', None) if None in (name, uid): raise EnvironmentError('No user is currently checked-in.') try: user = session.query(User)\ .filter(User.name.ilike(name), User.uid == uid).one() except NoResultFound: same_name = session.query(User)\ .filter(User.name.ilike(name)).count() same_uid = session.query(User).filter(User.uid == uid).count() if same_name or same_uid: raise ValueError( f'User name/uid mismatch.\n' f'{same_name} user{"s" if same_name != 1 else ""} have the ' f'same name : {name}\n' f'{same_uid} user{"s" if same_uid != 1 else ""} have the ' f'same unique id : {uid}' ) user = User(name=name, uid=uid) session.add(user) session.commit() return user
def music(self): app = QtCore.QCoreApplication(sys.argv) url = QtCore.QUrl.fromLocalFile("./fairydust.mp3") content = M.QMediaContent(url) player = M.QMediaPlayer() player.setMedia(content) player.play()
def pyside(): import PySide from PySide import QtGui, QtCore, QtUiTools remap(PySide, "QtWidgets", QtGui) remap(QtCore, "QSortFilterProxyModel", QtGui.QSortFilterProxyModel) remap(QtCore, "QStringListModel", QtGui.QStringListModel) remap(QtCore, "QItemSelection", QtGui.QItemSelection) remap(QtCore, "QItemSelectionModel", QtGui.QItemSelectionModel) remap(QtCore, "QAbstractProxyModel", QtGui.QAbstractProxyModel) try: from PySide import QtWebKit remap(PySide, "QtWebKitWidgets", QtWebKit) except ImportError: # QtWebkit is optional in Qt , therefore might not be available pass add(PySide, "__wrapper_version__", __version__) add(PySide, "__binding__", "PySide") add(PySide, "__binding_version__", PySide.__version__) add(PySide, "__qt_version__", PySide.QtCore.qVersion()) add(PySide, "__added__", __added__) add(PySide, "__remapped__", __remapped__) add(PySide, "__modified__", __modified__) add(PySide, "load_ui", lambda fname: QtUiTools.QUiLoader().load(fname)) add(PySide, "convert", convert) add(PySide, "translate", lambda context, sourceText, disambiguation, n: QtCore.QCoreApplication( context, sourceText, disambiguation, None, n)) return PySide
def main(): args = parse_args() db = args.dbnames #all_dbs = args.dbnames f = open(args.sm_file) mol_list = [] for line in f: mol_list.append(line[:-1]) similarity_cutoff = args.cutoff return_count = args.return_count # Try to connect to the GPU backend app = QtCore.QCoreApplication([]) cmdline = [GPUSIM_EXEC] cmdline += ['--gpu_bitcount', args.gpu_bitcount] cmdline += db backend_proc = subprocess.Popen(cmdline, stdout=subprocess.PIPE) setup_socket(app) output = backend_proc.stdout.readline() if os.path.exists(args.res_file): f = open(args.res_file, "a") else: f = open(args.res_file, "w") f.writelines("src_smiles,result,similarity,db_id\n") for mol in mol_list: print(mol) approximate_results, smiles, ids, scores, src_smiles = \ search_for_results(mol, return_count, similarity_cutoff, ["default"], [""]) print("Results: ", approximate_results) if len(smiles) > 0: for i in range(len(smiles)): f.writelines(src_smiles + "," + smiles[i] + "," + str(scores[i]) + "," + str(ids[i]) + "\n") f.close() backend_proc.kill()
def main(): args = parse_args() app = QtCore.QCoreApplication([]) socket = QtNetwork.QLocalSocket(app) smiles = input("Smiles: ") dbcount = 1 dbname = args.dbname dbkey = args.dbkey socket.connectToServer('gpusimilarity') while smiles and smiles.lower() not in ('quit', 'exit'): return_count = 20 similarity_cutoff = 0 fp_binary, _ = smiles_to_fingerprint_bin(smiles) fp_qba = QtCore.QByteArray(fp_binary) output_qba = QtCore.QByteArray() output_qds = QtCore.QDataStream(output_qba, QtCore.QIODevice.WriteOnly) output_qds.writeInt(dbcount) output_qds.writeString(dbname.encode()) output_qds.writeString(dbkey.encode()) request_num = random.randint(0, 2**31) output_qds.writeInt(request_num) output_qds.writeInt(return_count) output_qds.writeFloat(similarity_cutoff) output_qds << fp_qba socket.write(output_qba) socket.flush() socket.waitForReadyRead(30000) output_qba = socket.readAll() smiles = [] scores = [] ids = [] data_reader = QtCore.QDataStream(output_qba) returned_request = data_reader.readInt() if request_num != returned_request: raise RuntimeError("Incorrect result ID returned!") return_count = data_reader.readInt() approximate_matches = data_reader.readUInt64() for i in range(return_count): smiles.append(data_reader.readString()) for i in range(return_count): ids.append(data_reader.readString()) for i in range(return_count): scores.append(data_reader.readFloat()) print("Approximate total matches: {0}, returning {1}".format( approximate_matches, return_count)) for cid, smi, score in zip(ids, smiles, scores): print("{0} {1}: {2}".format(cid, smi, score)) smiles = input("Smiles: ")
def main(): global sockets args = parse_args() # Try to connect to the GPU backend app = QtCore.QCoreApplication([]) procs = [] for dbname in args.dbnames: # Start the GPU backend cmdline = [FASTSIM_EXEC, dbname] if args.cpu_only: cmdline.append('--cpu_only') procs.append(subprocess.Popen(cmdline)) socket = QtNetwork.QLocalSocket(app) dbname_noext = os.path.splitext(os.path.basename(dbname))[0] sockets[dbname_noext] = socket while not socket.isValid(): socket_name = os.path.splitext(os.path.basename(dbname))[0] socket.connectToServer(socket_name) time.sleep(0.3) if args.http_interface: handler = FastSimHTTPHandler else: handler = FastSimHandler server = ThreadedHTTPServer((args.hostname, args.port), handler) print("Running HTTP server...") server.serve_forever() for proc in procs: proc.kill()
def _pyside(): import PySide from PySide import QtGui, QtCore, QtUiTools _remap(PySide, "QtWidgets", QtGui) _remap(QtCore, "QSortFilterProxyModel", QtGui.QSortFilterProxyModel) _remap(QtCore, "QStringListModel", QtGui.QStringListModel) _remap(QtCore, "QItemSelection", QtGui.QItemSelection) _remap(QtCore, "QItemSelectionModel", QtGui.QItemSelectionModel) _remap(QtCore, "QAbstractProxyModel", QtGui.QAbstractProxyModel) try: from PySide import QtWebKit _remap(PySide, "QtWebKitWidgets", QtWebKit) except ImportError: # QtWebkit is optional in Qt, therefore might not be available pass _add(PySide, "__binding__", PySide.__name__) _add(PySide, "load_ui", lambda fname: QtUiTools.QUiLoader().load(fname)) _add(PySide, "translate", lambda context, sourceText, disambiguation, n: ( QtCore.QCoreApplication(context, sourceText, disambiguation, None, n))) _add(PySide, "setSectionResizeMode", QtGui.QHeaderView.setResizeMode) _maintain_backwards_compatibility(PySide) return PySide
def main(): import sys app = QtCore.QCoreApplication(sys.argv) from artisanlib.acaia import AcaiaBLE acaia = AcaiaBLE() ble = BleInterface(acaia.SERVICE_UUID,acaia.CHAR_UUID,acaia.processData,acaia.sendHeartbeat,acaia.sendStop,acaia.reset) ble.scanDevices() sys.exit(app.exec_())
def __init__(self): super().__init__() self.music = C.QCoreApplication(sys.argv) url = C.QUrl.fromLocalFile("./orange.mp3") content = M.QMediaContent(url) self.player = M.QMediaPlayer() self.player.setMedia(content) self.player.play()
def main(): if is_server_dbus_running(): print('server dbus is running, ignore') return server_dbus = ServerDBus() # FIXME: log service failed to dump log server_log.debug('Init server dbus: %s' % server_dbus) print('server dbus inited') app = QtCore.QCoreApplication(sys.argv) app.exec()
def setUp(self): """ We need to setup a QCoreApplication because the QThread stuff expects an event loop to be present. Since we never start the event loop we need to process events manually. """ self.app = QtCore.QCoreApplication([]) self.fdsnws_runner = FDSNWSRunner(None) self.fdsnws_runner._importer._run = mock_run
def test_close(self): """ Test if closing the project emits the will_close signal """ app = QtCore.QCoreApplication([]) mock_store = MagicMock() mock_signal_handler = MagicMock() project = Project(mock_store) project.will_close.connect(mock_signal_handler) project.close() app.processEvents() mock_signal_handler.assert_called_once_with(project)
def nextpage(self): self.count += 1 print(self.count) if self.count == 1: self.screen.setPixmap(QtGui.QPixmap("img/sc2.png")) elif self.count == 2: app = QtCore.QCoreApplication([]) #start_timer(timer_func, 10) self.show_icon() elif self.count == 3: self.screen.setPixmap(QtGui.QPixmap("img/screen.png"))
def test_update_project_time(self): """ Test if the project_time_changed signal is emitted as expected """ self.project = Project(self.store_mock) app = QtCore.QCoreApplication([]) handler = MagicMock() self.project.project_time_changed.connect(handler) t = datetime(2020, 1, 1, 17) self.project.update_project_time(t) app.processEvents() handler.assert_called_once_with(t)
def check_in(name: str, uid: bytes): """ Gets or creates a User and returns the instance. User names for identifying edits, and not keeping people from reading our data. Raises an exception if the name and uid do not match. """ app = QtCore.QCoreApplication.instance() or QtCore.QCoreApplication(sys.argv) settings = QtCore.QSettings(ORG_NAME, APP_NAME) settings.setValue('User.name', name) settings.setValue('User.uid', uid)
def pyqt4(): # Attempt to set sip API v2 (must be done prior to importing PyQt4) import sip try: sip.setapi("QString", 2) sip.setapi("QVariant", 2) sip.setapi("QDate", 2) sip.setapi("QDateTime", 2) sip.setapi("QTextStream", 2) sip.setapi("QTime", 2) sip.setapi("QUrl", 2) except AttributeError: raise ImportError # PyQt4 < v4.6 except ValueError: # API version already set to v1 raise ImportError import PyQt4.Qt from PyQt4 import QtCore, QtGui, uic remap(PyQt4, "QtWidgets", QtGui) remap(QtCore, "Signal", QtCore.pyqtSignal) remap(QtCore, "Slot", QtCore.pyqtSlot) remap(QtCore, "Property", QtCore.pyqtProperty) remap(QtCore, "QItemSelection", QtGui.QItemSelection) remap(QtCore, "QStringListModel", QtGui.QStringListModel) remap(QtCore, "QItemSelectionModel", QtGui.QItemSelectionModel) remap(QtCore, "QSortFilterProxyModel", QtGui.QSortFilterProxyModel) remap(QtCore, "QAbstractProxyModel", QtGui.QAbstractProxyModel) try: from PyQt4 import QtWebKit remap(PyQt4, "QtWebKitWidgets", QtWebKit) except ImportError: # QtWebkit is optional in Qt , therefore might not be available pass add(PyQt4, "__wrapper_version__", __version__) add(PyQt4, "__binding__", "PyQt4") add(PyQt4, "__binding_version__", QtCore.PYQT_VERSION_STR) add(PyQt4, "__qt_version__", QtCore.QT_VERSION_STR) add(PyQt4, "__added__", __added__) add(PyQt4, "__remapped__", __remapped__) add(PyQt4, "__modified__", __modified__) add(PyQt4, "load_ui", lambda fname: uic.loadUi(fname)) add(PyQt4, "convert", convert) add(PyQt4, "translate", lambda context, sourceText, disambiguation, n: QtCore.QCoreApplication( context, sourceText, disambiguation, None, n)) return PyQt4
def create_QApplication(): QtCore.QThread.currentThread().setObjectName("MAIN") # For DEBUG info app = 0 # Work-around for kernel crash when using Spyder IDE # QtWidgets are not needed for pytest and will fail standard Travis test # app = QtWidgets.QApplication(sys.argv) app = QtCore.QCoreApplication(sys.argv) # Use QCoreApplication instead global cnt_DAQ_updated, cnt_DAQ_paused, cnt_jobs_updated cnt_DAQ_updated = 0 cnt_DAQ_paused = 0 cnt_jobs_updated = 0 return app
def main(): """ This script allows you to run this module as a standalone Python program. """ app = QtCore.QCoreApplication([]) inf = input('Input file: ') outf = input('Output file: ') with open(inf, 'rb') as inf: inb = inf.read() outImg = renderGTX(loadGTX(inb)) outImg.save(outf)
def _pyqt4(): # Attempt to set sip API v2 (must be done prior to importing PyQt4) import sip try: sip.setapi("QString", 2) sip.setapi("QVariant", 2) sip.setapi("QDate", 2) sip.setapi("QDateTime", 2) sip.setapi("QTextStream", 2) sip.setapi("QTime", 2) sip.setapi("QUrl", 2) except AttributeError: raise ImportError # PyQt4 < v4.6 except ValueError: # API version already set to v1 raise ImportError import PyQt4.Qt from PyQt4 import QtCore, QtGui, uic _remap(PyQt4, "QtWidgets", QtGui) _remap(QtCore, "Signal", QtCore.pyqtSignal) _remap(QtCore, "Slot", QtCore.pyqtSlot) _remap(QtCore, "Property", QtCore.pyqtProperty) _remap(QtCore, "QItemSelection", QtGui.QItemSelection) _remap(QtCore, "QStringListModel", QtGui.QStringListModel) _remap(QtCore, "QItemSelectionModel", QtGui.QItemSelectionModel) _remap(QtCore, "QSortFilterProxyModel", QtGui.QSortFilterProxyModel) _remap(QtCore, "QAbstractProxyModel", QtGui.QAbstractProxyModel) try: from PyQt4 import QtWebKit _remap(PyQt4, "QtWebKitWidgets", QtWebKit) except ImportError: # QtWebkit is optional in Qt , therefore might not be available pass _add(PyQt4, "QtCompat", self) _add(PyQt4, "__binding__", PyQt4.__name__) _add(PyQt4, "load_ui", lambda fname: uic.loadUi(fname)) _add( PyQt4, "translate", lambda context, sourceText, disambiguation, n: (QtCore.QCoreApplication(context, sourceText, disambiguation, None, n) )) _add(PyQt4, "setSectionResizeMode", QtGui.QHeaderView.setResizeMode) _maintain_backwards_compatibility(PyQt4) return PyQt4
def main(): filename = os.path.join(CURRENT_DIR, "sound.mp3") app = QtCore.QCoreApplication(sys.argv) player = QtMultimedia.QMediaPlayer() url = QtCore.QUrl.fromLocalFile(filename) player.setMedia(QtMultimedia.QMediaContent(url)) player.play() # end in 5 seconds: QtCore.QTimer.singleShot(5 * 1000, app.quit) sys.exit(app.exec_())
def __init__(self): super().__init__() self.music = C.QCoreApplication(sys.argv) url = C.QUrl.fromLocalFile("./orange.mp3") content = M.QMediaContent(url) self.player = M.QMediaPlayer() self.player.setMedia(content) self.player.play() self.title = 'PyQt absolute positioning - pythonspot.com' self.left = 10 self.top = 10 self.width = 440 self.height = 280 self.initUI()
def _setup(): if self.app is None: self.app = QtCore.QCoreApplication.instance() if self.app is None: self.app = QtCore.QCoreApplication(sys.argv) service = pyblish_rpc.service.RpcService() self.server = pyblish_rpc.server._server(self.port, service) self.thread = threading.Thread(target=self.server.serve_forever) self.thread.daemon = True self.thread.start() clean()
def setUp(self): """ Test Preparation The simulator should deliver the time change signal in intervals of one second divided by TEST_SPEED. Since the simulator delivers event through the QtCore event loop, we need to setup a qt application. """ self.app = QtCore.QCoreApplication([]) self.history = [] self.time_step = 1 / TEST_SPEED self.simulator = Simulator(self._callback) # state variables self.simulation_time = None self.t_elapsed = 0
def run(self): """ Runs the server process by starting its own QCoreApplication. """ # because PyQt5 eats exceptions in the event thread this workaround sys.excepthook = start.exception_hook app = QtCore.QCoreApplication([]) # server manager, signal shutdown stops the app server_manager = ServerManager() server_manager.shutdown.connect(app.quit) # noinspection PyCallByClass QtCore.QTimer.singleShot(100, server_manager.start) # run event loop of app app.exec_()
def run(self): """ Runs the server process by starting its own QCoreApplication. """ self._configure_forked_logger() qt.fix_pyqt5_exception_eating() app = QtCore.QCoreApplication([]) # server manager, signal shutdown stops the app server_manager = ServerManager() server_manager.shutdown.connect(app.quit) # noinspection PyCallByClass QtCore.QTimer.singleShot(100, server_manager.start) # run event loop of app app.exec_()
def _pyside2(): import PySide2 from PySide2 import QtGui, QtWidgets, QtCore, QtUiTools _remap(QtCore, "QStringListModel", QtGui.QStringListModel) _add(PySide2, "__binding__", PySide2.__name__) _add(PySide2, "load_ui", lambda fname: QtUiTools.QUiLoader().load(fname)) _add(PySide2, "translate", lambda context, sourceText, disambiguation, n: ( QtCore.QCoreApplication(context, sourceText, disambiguation, None, n))) _add(PySide2, "setSectionResizeMode", QtWidgets.QHeaderView.setSectionResizeMode) _maintain_backwards_compatibility(PySide2) return PySide2
def __init__(self, args): """ Instantiates the Ramsis core and the Qt app (run loop) and wires the GUI. :param args: command line arguments that were provided by the user """ super().__init__() self.thread().setObjectName('Main') # Setup the logger self.logger = logging.getLogger(__name__) self.logger.info('Launching RAMSIS v' + VERSION) # Instantiate the appropriate Qt app object self.has_gui = not args.no_gui if self.has_gui: # QApplication.setStyle( # QStyleFactory.create('Cleanlooks')) self.qt_app = QApplication(sys.argv) # QgsApplication.initQgis() else: self.qt_app = QtCore.QCoreApplication(sys.argv) # Register some general app information self.qt_app.setApplicationName('Ramsis') self.qt_app.setOrganizationDomain('seismo.ethz.ch') self.qt_app.setApplicationVersion(VERSION) self.qt_app.setOrganizationName('SED') # Load settings path = args.config if args.config else 'ramsis.ini' settings_file = os.path.abspath(path) self.app_settings = AppSettings(settings_file) # Enable Ctrl-C signal.signal(signal.SIGINT, self._on_sigint) # Once the Qt event loop is running, we need a timer to periodically # run the Python interpreter so it can process Ctrl-C signals self.timer = QtCore.QTimer() self.timer.timeout.connect(lambda: None) self.timer.start(500) # Launch core self.ramsis_core = Controller(settings=self.app_settings) if self.has_gui: self.main_window = MainWindow(self) self.app_launched.connect(self.on_app_launched)
def _pyqt5(): import PyQt5.Qt from PyQt5 import QtCore, QtWidgets, uic _remap(QtCore, "Signal", QtCore.pyqtSignal) _remap(QtCore, "Slot", QtCore.pyqtSlot) _remap(QtCore, "Property", QtCore.pyqtProperty) _add(PyQt5, "__binding__", PyQt5.__name__) _add(PyQt5, "load_ui", lambda fname: uic.loadUi(fname)) _add( PyQt5, "translate", lambda context, sourceText, disambiguation, n: (QtCore.QCoreApplication(context, sourceText, disambiguation, n))) _add(PyQt5, "setSectionResizeMode", QtWidgets.QHeaderView.setSectionResizeMode) _maintain_backwards_compatibility(PyQt5) return PyQt5